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

..
Автор SHA1 Повідомлення Дата
l0ng-ai e091561937 style(cucumber): format the Python step files 2026-11-21 01:22:20 +08:00
l0ng-ai 423bf2c733 fix(settings): align Code Completion case choices (#4852)
Settings > Editor > General > Code Completion shows both case-matching choices beside the Match case checkbox; the options wrap when space is limited and stay visible when disabled, so the saved choice is easy to see.
2026-11-21 01:11:23 +08:00
l0ng-ai 73d1470940 fix(settings): align Actions on Save in a table (#4848)
Settings > Tools > Actions on Save groups the three save preferences in a table: each row keeps its description with the checkbox and shows Save or Save All in the trigger column while enabled; the scope switch and the whitespace settings link stay below the table.
2026-11-21 00:57:56 +08:00
l0ng-ai c83b0b1442 fix(settings): pair postfix templates with a code preview (#4843)
Settings > Editor > General > Postfix Completion puts the template list beside a preview of the selected template, showing the typed expression and its expansion from the existing template body; in narrow panes the preview moves below the list.
2026-11-21 00:41:46 +08:00
l0ng-ai d16993e175 fix(lsp): end a cancelled server task the server never ends (#4842)
Cancelling a server-reported background task (window/workDoneProgress/cancel) left it on Cancelling for good when the server never sent end, e.g. Pyright stuck before loading its workspace. The server now gets five seconds to end the task; after that the IDE ends it and clears the server's busy state, ignoring later reports on that token.
2026-11-21 00:36:53 +08:00
l0ng-ai 5d4cdac3c7 fix(settings): align the File Colors rules table (#4839)
Settings > Editor > File Colors puts the placement switches together above the rules; a table keeps scope names aligned with their swatches and colour names, with the toolbar and headings sticky while the rules scroll. The selected rule's editor sits directly below the table, and the colour controls wrap in narrow panes so the full hex value stays visible.
2026-11-21 00:25:48 +08:00
l0ng-ai 9c414cc75c fix(settings): align Editor General controls (#4827)
Settings > Editor > General: the mouse-wheel zoom scope choices sit beneath their checkbox as radio buttons, the soft-wrap file patterns field sits beside its checkbox (wrapping underneath in a narrow pane), and Scrolling follows Virtual Space with each caret behaviour on its own line.
2026-11-21 00:10:18 +08:00
Vladislav Kuzmin 3bbc90d750 test(debugger): expect watch for explicit Quick Evaluate (#4837)
Explicit Quick Evaluate sends DAP context watch since #4801 so method calls can run; the layout e2e test now expects watch for both evaluations.

Co-authored-by: principalwater <[email protected]>

Co-authored-by: principalwater <[email protected]>
2026-11-21 00:03:02 +08:00
ntbang0901 6d157c8b71 fix(debugger): stop at an uncaught exception from a traced stream so its records stay (#4851)
When a traced stream's terminal operation threw something the program does not catch, the trace lost its records: ide-dap reads them in the stop after its stepOut, and an uncaught exception ends the thread without one. Before parking a trace whose terminal threw, the jvm-inspect bundle now adds an uncaught-only ExceptionRequest on the traced thread (unless an enabled java-debug request already stops there), so the program stops at that throw and the trace shows the records with the exception. Bundle 1.1.1; the jar was rebuilt from source and matches byte for byte.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:57:05 +08:00
l0ng-ai f2c0fcdc96 fix(settings): align Smart Keys backspace and paste controls (#4823)
Settings > Editor > General > Smart Keys places the Backspace and paste formatting controls directly below the Enter options; the two controls share a label column and the paste escaping option sits below the formatting control.
2026-11-20 23:54:10 +08:00
ntbang0901 a4574fdc92 fix(debugger): show toString() of Java values instead of a nameless child row (#4857)
Java values whose class overrides toString() showed without their text, and opening them showed one nameless row with the fields a level deeper. java-debug marks these values with DAP presentationHint.lazy and the IDE ignored it. Variables now carry lazy; debug_resolve_variable merges the adapter's single inner variable into the row; debugger configs can declare resolve-lazy-variables (on for java-debug) so variables/evaluate return resolved values; other adapters resolve a lazy row in place when it is opened or its (...) marker is clicked.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:53:34 +08:00
ntbang0901 4bc87f5d84 fix(debugger): stay suspended on a thread its breakpoint still holds after another resumes (#4858)
Java debugging suspends only the thread that hits a breakpoint, but the Debug window tracked one stopped thread: after resuming it, the window showed Running with Resume and Step disabled while another thread was still stopped. The session now tracks every thread stopped alone (stopped adds, continued removes) and moves to a remaining stopped thread when the shown one continues; steps report all_threads_continued false since they run only their thread.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:50:14 +08:00
ntbang0901 39671ff55b fix(vcs): merge and rebase branches by their short name (#4850)
Merging a branch from the Branches popup recorded "Merge branch 'refs/heads/feature'" (and the rebase reflog "checkout refs/heads/feature") because the popup passes the full ref to avoid tags of the same name. Merge and rebase now pass the short name when it resolves to that same branch, and keep the full ref when a tag shares the name.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:47:32 +08:00
ntbang0901 881812547d fix(vcs): open the Conflicts dialog when an unstash stops on conflicts (#4849)
Applying or popping a stash that conflicts with the working tree showed an error balloon instead of the conflict resolver. unstash() was the only operation that can stop on conflicts without the conflict handler; it now uses conflictsInstead like merge, rebase and unshelve, so the Conflicts dialog opens. Other unstash failures still report the error.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:46:47 +08:00
ntbang0901 9c145ea258 fix(run): run a Gradle subproject's tests with that subproject's test task (#4846)
In a Gradle multi-project build, gutter class/method runs, Run on a test file and JUnit configurations used the build's plain test task, so --tests filtered every subproject and the first one without a match failed the build before the subproject holding the test ran. They now share inGradleModule (the lookup directory runs already used) and run :<subproject>:test --tests ...; reruns and test-tree selections inherit that task.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:45:45 +08:00
ntbang0901 4f192a12bc fix(run): let Maven reactor modules without the selected tests pass in every test run (#4845)
In a Maven multi-module project, Rerun Failed Tests and Run on a test file failed before the selected tests ran: -Dtest reached the first module without a matching test and Surefire stopped the build, skipping the module with the test. Those two paths built -Dtest themselves without -Dsurefire.failIfNoSpecifiedTests=false; every Maven test selection now goes through withMavenTests, which replaces an earlier -Dtest and always adds the flag.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:44:02 +08:00
ntbang0901 1d857375dc fix(vcs): open a multi-line selection's lines on the Git remote from Open In (#4844)
Editor > Open In > GitHub / GitLab / Bitbucket opened only the caret line even with several lines selected. The editor menu passed the caret line only and vcs.openOnRemote dropped endLine; the menu now takes its lines from the helper Copy Path/Reference uses (moved to selectedLines.ts) and Open In keeps endLine.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:43:20 +08:00
Vladislav Kuzmin 6543cdb36b test(debugger): expect unquoted strings in the value dialog (#4836)
The full-value dialog shows a string without its adapter quotes; the debugger layout e2e test now asserts the unquoted text there and keeps the quoted value in the Variables row.

Co-authored-by: principalwater <[email protected]>

Co-authored-by: principalwater <[email protected]>
2026-11-20 23:42:46 +08:00
Vladislav Kuzmin 684c92ce90 test(settings): target the exact font preview textbox (#4833)
The font-family e2e test matched both the editable preview and its resize handle through a substring label lookup; it now targets the textbox by its exact accessible name.

Co-authored-by: principalwater <[email protected]>

Co-authored-by: principalwater <[email protected]>
2026-11-20 23:42:38 +08:00
l0ng-ai 9a77a95180 feat(cucumber): behave and pytest-bdd step definitions in Python (#4859)
Python step definitions for Gherkin: behave decorators with its parse / cfparse / re matchers (use_step_matcher switches them), and pytest-bdd's exact strings and parsers.parse / cfparse / re. Covers navigation both ways, the Undefined step check and Create step definition (pending step_impl for behave, def _() for pytest-bdd, decorator added to the existing import). The backend scan reads .py files with a step decorator and skips site-packages.
2026-11-20 23:41:43 +08:00
l0ng-ai 1000ef0fa0 fix(editor): align code folding controls and arrow visibility (#4820)
Settings > Editor > General > Code Folding puts the outline visibility next to Show code folding outline (On hover / Always, new editor setting folding.outlineVisibility, default On hover) and lists the Fold by default options in one column. With Always, open fold arrows stay visible without hovering the gutter.
2026-11-20 23:40:32 +08:00
l0ng-ai 654da3e1ef feat(editor): spinner in progress hints (#4854)
Pending editor hints (Finding navigation target and other progress hints) start with the ring spinner used elsewhere in the UI; final hints are unchanged.
2026-11-20 23:21:16 +08:00
l0ng-ai ba6ccaf9b2 feat(vcs): option to open diffs in a separate window (#4853)
Adds Settings > Version Control > Confirmation > Open diff as editor tab (default on, client-side workflow setting vcs.diffAsEditorTab). When off, diffs opened from the Commit tool window, history, log and Compare show in a separate Diff window; combined multi-file diffs still open as a tab.
2026-11-20 23:17:37 +08:00
87 змінених файлів з 2851 додано та 423 видалено

No files matched your search

+37 -1
Переглянути файл
@@ -197,6 +197,7 @@ pub enum ImportsOnPaste {
#[serde(default, rename_all = "camelCase")]
pub struct FoldingSettings {
pub show_outline: bool,
pub outline_visibility: FoldingOutlineVisibility,
pub file_header: bool,
pub imports: bool,
pub doc_comments: bool,
@@ -204,10 +205,24 @@ pub struct FoldingSettings {
impl Default for FoldingSettings {
fn default() -> Self {
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
Self {
show_outline: true,
outline_visibility: FoldingOutlineVisibility::Hover,
file_header: true,
imports: true,
doc_comments: false,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum FoldingOutlineVisibility {
#[default]
Hover,
Always,
}
/// Editor › General › Editor Tabs.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -543,3 +558,24 @@ mod auto_import_tests {
}
}
}
#[cfg(test)]
mod folding_tests {
use super::{FoldingOutlineVisibility, FoldingSettings};
#[test]
fn folding_outline_defaults_to_hover_for_existing_settings() {
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
assert!(!settings.show_outline);
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
}
#[test]
fn folding_outline_visibility_round_trips() {
for mode in ["hover", "always"] {
let json = serde_json::json!({ "outlineVisibility": mode });
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
}
}
}
+13 -6
Переглянути файл
@@ -49,6 +49,8 @@ pub struct AdapterSpec {
pub connect: Option<String>,
/// A plugin language's adapter: start exactly this approved program.
pub pinned: Option<ProgramPin>,
/// See [`DebuggerConfig::resolve_lazy_variables`].
pub resolve_lazy_variables: bool,
}
/// Built-in adapters used when no language definition names `adapter`.
@@ -60,6 +62,7 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
transport: transport.to_owned(),
connect: None,
install_hint: Some(hint.to_owned()),
resolve_lazy_variables: false,
pinned: None,
};
Some(match adapter {
@@ -130,12 +133,15 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
),
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
"java-debug" => cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
),
"java-debug" => DebuggerConfig {
resolve_lazy_variables: true,
..cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
)
},
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
// runs the executable of the java-analyzer serving the module.
JAVA_ANALYZER => cfg(
@@ -186,6 +192,7 @@ pub fn resolve(config: &DebuggerConfig, cwd: PathBuf) -> AdapterSpec {
server_host: None,
connect: config.connect.clone(),
pinned: config.pinned.clone(),
resolve_lazy_variables: config.resolve_lazy_variables,
}
}
+1
Переглянути файл
@@ -102,6 +102,7 @@ pub(crate) fn bare_session_of(name: &str, request: &str) -> BareSession {
server_host: None,
connect: None,
pinned: None,
resolve_lazy_variables: false,
};
let session = Session::new(
DebugSessionId(1),
+64 -14
Переглянути файл
@@ -236,6 +236,11 @@ pub struct Variable {
/// > 0 when expandable.
pub variables_reference: i64,
pub evaluate_name: Option<String>,
/// `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
/// `variables` returns for `variables_reference` holds the value and its children.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
#[specta(optional)]
pub lazy: bool,
}
/// A completion the adapter offers for an expression (DAP `completions`).
@@ -727,9 +732,46 @@ pub(crate) fn variable_from(v: &Value) -> Variable {
type_name: s("type").filter(|t| !t.is_empty()),
variables_reference: v.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: s("evaluateName"),
lazy: v.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
}
}
async fn session_variables(session: &Session, reference: i64) -> IdeResult<Vec<Variable>> {
let body =
session.conn.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT).await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
}
async fn resolve_in(session: &Session, variable: Variable) -> IdeResult<Variable> {
if !variable.lazy || variable.variables_reference <= 0 {
return Ok(variable);
}
let mut inner = session_variables(session, variable.variables_reference).await?;
Ok(match (inner.pop(), inner.is_empty()) {
(Some(value), true) => Variable {
type_name: value.type_name.or(variable.type_name),
evaluate_name: variable.evaluate_name.or(value.evaluate_name),
name: variable.name,
value: value.value,
variables_reference: value.variables_reference,
lazy: value.lazy,
},
_ => variable,
})
}
/// A value that cannot be computed stays lazy, so the row can still be opened by hand.
async fn resolve_lazy(session: &Session, variable: Variable) -> Variable {
if !variable.lazy {
return variable;
}
resolve_in(session, variable.clone()).await.unwrap_or(variable)
}
impl DebugManager {
pub fn new(languages: Arc<LanguageRegistry>) -> Arc<Self> {
Self::with_launcher(languages, Arc::new(ProcessLauncher))
@@ -1497,6 +1539,7 @@ impl DebugManager {
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: evaluate_name.or(Some(name)),
lazy: false,
})
}
@@ -1567,16 +1610,18 @@ impl DebugManager {
}
pub async fn variables(&self, s: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
let body = self
.session(s)?
.conn
.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT)
.await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
let session = self.session(s)?;
let vars = session_variables(&session, reference).await?;
if !session.spec.resolve_lazy_variables {
return Ok(vars);
}
Ok(join_all(vars.into_iter().map(|v| resolve_lazy(&session, v))).await)
}
/// Computes a lazy variable's value (DAP `presentationHint.lazy`); any other variable, or one
/// whose value the adapter does not give as a single variable, comes back unchanged.
pub async fn resolve_variable(&self, s: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
resolve_in(&*self.session(s)?, variable).await
}
/// Evaluates in the `repl` context.
@@ -1602,13 +1647,18 @@ impl DebugManager {
args["frameId"] = f.into();
}
let body = session.conn.request_timeout("evaluate", args, REQUEST_TIMEOUT).await?;
Ok(Variable {
let result = Variable {
name: expression.clone(),
value: body.get("result").and_then(Value::as_str).unwrap_or_default().to_owned(),
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: Some(expression),
})
lazy: body.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
};
if !session.spec.resolve_lazy_variables {
return Ok(result);
}
Ok(resolve_lazy(&session, result).await)
}
/// Completions for `text` at `line` / `column` (0-based, UTF-16) in the frame's scope; none
@@ -1713,7 +1763,7 @@ impl DebugManager {
// A step runs its thread; other threads stopped by their own events stay stopped.
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
Ok(())
}
@@ -1825,7 +1875,7 @@ impl DebugManager {
step_settled(&session, sent)?;
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
Ok(())
}
+71 -7
Переглянути файл
@@ -505,13 +505,29 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
"scopes" => {
ok!(msg, json!({"scopes": [{"name": "Locals", "variablesReference": 100, "expensive": false}]}))
}
"variables" => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
// 200 holds a lazy value (java-debug's toString(), js-debug's getters): asked for, its
// reference answers one nameless child with the value and the reference of its fields.
"variables" => match msg["arguments"]["variablesReference"].as_i64() {
Some(200) => ok!(
msg,
json!({"variables": [
{"name": "order", "value": "Order@7", "type": "Order", "variablesReference": 201,
"evaluateName": "order", "presentationHint": {"lazy": true}},
{"name": "n", "value": "2", "type": "int", "variablesReference": 0, "presentationHint": {"lazy": false}},
]})
),
Some(201) => ok!(
msg,
json!({"variables": [{"name": "", "value": "Order@7 \"Order(1)\"", "variablesReference": 202, "evaluateName": "order"}]})
),
_ => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
},
"evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
"completions" => ok!(
msg,
@@ -2020,6 +2036,7 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
transport: "tcp".into(),
connect: Some(format!("127.0.0.1:{port}")),
install_hint: Some("Open the project in the Godot editor".into()),
resolve_lazy_variables: false,
pinned: None,
}),
};
@@ -2763,6 +2780,53 @@ async fn step_of_one_thread_keeps_the_others_suspended() {
assert_eq!(session.suspended.ticket(), ticket + 1);
h.manager.step_in_target(id, 7, 1).await.unwrap();
assert!(!session.suspended.get());
// The UI stays on a thread that is still stopped only when told the step ran one thread.
for thread in [7, 8] {
let continued =
h.wait_event(|e| matches!(e, DebugEvent::Continued { thread_id, .. } if *thread_id == thread)).await;
assert!(matches!(continued, DebugEvent::Continued { all_threads_continued: false, .. }), "{continued:?}");
}
}
#[tokio::test]
async fn lazy_variables_are_resolved_when_the_adapter_declares_them_safe() {
let h = harness(Script::default());
let id = h.start(java_config("launch")).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
let order = &vars[0];
assert_eq!(
(order.name.as_str(), order.value.as_str(), order.type_name.as_deref()),
("order", "Order@7 \"Order(1)\"", Some("Order"))
);
assert_eq!((order.variables_reference, order.lazy), (202, false));
assert_eq!(order.evaluate_name.as_deref(), Some("order"));
assert_eq!((vars[1].name.as_str(), vars[1].lazy), ("n", false));
}
#[tokio::test]
async fn lazy_variables_stay_lazy_for_other_adapters() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
assert_eq!((vars[0].value.as_str(), vars[0].variables_reference, vars[0].lazy), ("Order@7", 201, true));
assert_eq!(requests(&h, "variables").len(), 1, "nothing is computed until asked for");
let order = h.manager.resolve_variable(id, vars[0].clone()).await.unwrap();
assert_eq!((order.name.as_str(), order.value.as_str()), ("order", "Order@7 \"Order(1)\""));
assert_eq!((order.variables_reference, order.lazy), (202, false));
let n = h.manager.resolve_variable(id, vars[1].clone()).await.unwrap();
assert_eq!((n.value.as_str(), requests(&h, "variables").len()), ("2", 2), "only lazy values are computed");
}
#[test]
fn java_debug_declares_its_lazy_variables_safe_to_resolve() {
let languages = LanguageRegistry::load(None).unwrap();
for registry in [&languages, &LanguageRegistry::from_configs(Vec::new())] {
assert!(adapter::find_config(registry, "java-debug").unwrap().resolve_lazy_variables);
assert!(!adapter::find_config(registry, "js-debug").unwrap().resolve_lazy_variables);
}
}
#[tokio::test]
+25 -4
Переглянути файл
@@ -1,6 +1,7 @@
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
//! `@given('…')` decorators) that could define steps, with their text. The UI
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
//! so this side stays a cheap scan.
@@ -21,6 +22,8 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
/** What a Python step decorator starts with (behave also takes the capitalized names). */
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -38,10 +41,14 @@ fn is_feature(path: &Path) -> bool {
fn is_script(path: &Path) -> bool {
matches!(
path.extension().and_then(|e| e.to_str()),
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
)
}
fn is_python(path: &Path) -> bool {
path.extension().and_then(|e| e.to_str()) == Some("py")
}
/// The feature files and step definition files under `root`.
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
@@ -55,7 +62,8 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
return;
}
let Ok(text) = std::fs::read_to_string(path) else { return };
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
if !feature && !calls.iter().any(|call| text.contains(call)) {
return;
}
let Ok(mut found) = found.lock() else { return };
@@ -76,6 +84,7 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
let mut excludes = project.search_excludes();
// Cucumber's own sources (and every other package's) are not the project's steps.
excludes.push("node_modules".to_owned());
excludes.push("site-packages".to_owned());
let mut out = Vec::new();
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
out.extend(sources_in(&root, &excludes));
@@ -104,11 +113,23 @@ mod tests {
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
.unwrap();
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
let files = sources_in(root, &["node_modules".to_owned()]);
let names: Vec<String> =
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
assert_eq!(
names,
[
"features/cart.feature",
"src/CartSteps.java",
"steps/bdd.mjs",
"steps/cart.steps.ts",
"steps/cart_steps.py"
]
);
assert!(files[0].feature && !files[1].feature);
assert!(files[3].text.contains("an empty cart"));
}
+6
Переглянути файл
@@ -342,6 +342,11 @@ pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i6
host.debugger.variables(session, reference).await
}
#[command(trust = trusted)]
pub async fn debug_resolve_variable(host: &Host, session: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
host.debugger.resolve_variable(session, variable).await
}
#[command(trust = trusted)]
pub async fn debug_evaluate(
host: &Host,
@@ -834,6 +839,7 @@ ide_command::domain!(
debug_listen_for_jvm,
debug_pause,
debug_redefine_classes,
debug_resolve_variable,
debug_restart_frame,
debug_resume,
debug_run_to,
+5
Переглянути файл
@@ -245,6 +245,11 @@ pub struct DebuggerConfig {
pub connect: Option<String>,
#[serde(default)]
pub install_hint: Option<String>,
/// The adapter's lazy values (DAP `presentationHint.lazy`) are renderings such as `toString()`,
/// safe to compute for every value shown: they are resolved before the UI sees them, as IDEA
/// shows `toString()` at once. Off (getters with side effects), a value resolves when opened.
#[serde(default)]
pub resolve_lazy_variables: bool,
/// Set on plugin languages: start exactly this approved program.
#[serde(skip)]
pub pinned: Option<ProgramPin>,
+44 -5
Переглянути файл
@@ -25,6 +25,17 @@ const PROGRESS_SWEEP: Duration = Duration::from_secs(15);
/// visible, but stops holding the server busy while the work behind it keeps running.
const PROGRESS_STALE: Duration = Duration::from_secs(180);
/// How long a cancelled progress task waits for its server to end it.
const CANCEL_GRACE: Duration = Duration::from_secs(5);
/// The key of progress token `token` in [`Server::progress`].
fn progress_key(token: &Value) -> String {
match token {
Value::String(s) => s.clone(),
other => other.to_string(),
}
}
/// Task message after [`PROGRESS_STALE`] of silence: keep the server's last message and
/// say how long nothing happened.
fn stalled_message(message: Option<&str>) -> String {
@@ -97,22 +108,50 @@ impl ClientHandler {
}
/// Cancelling task `task` asks this server instance to stop the work of progress `token`.
/// A server that never ends it (Pyright waiting on a workspace that never loads) would
/// leave the task "Cancelling…" for good: after [`CANCEL_GRACE`] the task ends here.
fn cancel_handle(&self, task: TaskId, token: &Value) -> ide_core::task::CancelHandle {
let (server, generation, token) = (self.server.clone(), self.generation, token.clone());
let (mgr, server, generation, token) = (self.mgr.clone(), self.server.clone(), self.generation, token.clone());
ide_core::task::on_cancel(task, move || {
if let Some(run) = server.initialized_gen(generation)
&& let Err(e) = run.peer.notify("window/workDoneProgress/cancel", json!({ "token": token }))
{
tracing::debug!("{}: cannot cancel progress: {e}", server.name);
}
let Some(runtime) = mgr.upgrade().map(|m| m.runtime.clone()) else { return };
runtime.spawn(async move {
tokio::time::sleep(CANCEL_GRACE).await;
let Some(mgr) = mgr.upgrade() else { return };
let key = progress_key(&token);
let ended = {
let mut progress = server.progress.lock();
if progress.get(&key).is_none_or(|p| p.task != task) {
return; // the server ended it, or the token began new work
}
progress.remove(&key)
};
if let Some(p) = ended {
tracing::info!("{}: progress '{key}' did not end after cancel; ending its task", server.name);
server.emit(
mgr.sink(),
IdeEvent::Task {
id: p.task,
title: p.title,
message: p.message,
fraction: None,
done: true,
cancellable: false,
},
);
server.refresh_busy_status(mgr.sink());
server.progress_ended();
}
});
})
}
fn progress(&self, mgr: &LspManager, params: Value) {
let token = match &params["token"] {
Value::String(s) => s.clone(),
other => other.to_string(),
};
let token = progress_key(&params["token"]);
let value = &params["value"];
let kind = value.get("kind").and_then(Value::as_str);
let message = value.get("message").and_then(Value::as_str).map(str::to_owned);
+46 -1
Переглянути файл
@@ -2,7 +2,7 @@
use ide_core::event::{LspRefreshKind, ServerStatus};
use ide_core::{
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, TaskId, WorkspaceEdit,
};
use ide_jsonrpc::{Handler, NoopHandler, Peer};
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
@@ -2182,6 +2182,51 @@ async fn replacing_progress_keeps_cancellation_reports_and_indexing_on_the_new_t
);
}
/// A server that ignores `window/workDoneProgress/cancel` (Pyright waiting on a workspace
/// that never loads) does not keep the task "Cancelling…": it ends after a grace period,
/// once, and later reports on the token change nothing. A server that ends it in time ends it.
#[tokio::test(flavor = "multi_thread")]
async fn a_cancelled_progress_the_server_never_ends_ends_on_its_own() {
let h = harness(&[("mock", incremental_caps())]);
h.open("a.mk", "x");
h.wait_status("mock", ServerStatus::Ready).await;
let s = h.launcher.state("mock");
let peer = s.peer();
let begin = |token: &str, title: &str| json!({ "token": token, "value": { "kind": "begin", "title": title, "cancellable": true } });
let task_of = |title: &str| {
h.events.lock().iter().find_map(|e| match e {
IdeEvent::Task { id, title: t, done: false, .. } if t == title => Some(*id),
_ => None,
})
};
let ends = |task: TaskId| {
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Task { id, done: true, .. } if *id == task)).count()
};
peer.notify("$/progress", begin("ignored", "Finding references")).unwrap();
peer.notify("$/progress", begin("honoured", "Indexing")).unwrap();
eventually(|| task_of("Finding references").is_some() && task_of("Indexing").is_some()).await;
h.wait_status("mock", ServerStatus::Busy).await;
let (ignored, honoured) = (task_of("Finding references").unwrap(), task_of("Indexing").unwrap());
assert!(ide_core::task::cancel(ignored));
assert!(ide_core::task::cancel(honoured));
eventually(|| s.notified("window/workDoneProgress/cancel").len() == 2).await;
peer.notify("$/progress", json!({ "token": "honoured", "value": { "kind": "end" } })).unwrap();
eventually(|| ends(honoured) == 1).await;
assert_eq!(ends(ignored), 0, "the server still has its grace period");
eventually(|| ends(ignored) == 1).await;
h.wait_status("mock", ServerStatus::Ready).await;
// Late reports on the token reach no task.
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "report", "message": "late" } })).unwrap();
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "end" } })).unwrap();
peer.notify("$/progress", begin("after", "After")).unwrap();
eventually(|| task_of("After").is_some()).await;
assert_eq!(ends(ignored), 1);
assert_eq!(ends(honoured), 1);
assert!(!h.events.lock().iter().any(|e| matches!(e, IdeEvent::Task { message: Some(m), .. } if m == "late")));
}
#[tokio::test(flavor = "multi_thread")]
async fn cancelling_a_cancellable_progress_task_asks_the_server_to_stop() {
let h = harness(&[("mock", incremental_caps())]);
+2 -2
Переглянути файл
@@ -1649,7 +1649,7 @@ pub fn jvm_inspect_bundle(data_dir: &Path) -> Option<PathBuf> {
install_bundle(
data_dir,
"jvm-inspect",
"1.1.0",
"1.1.1",
include_bytes!("../../../java/jvm-inspect/openidea-jvm-inspect.jar"),
)
}
@@ -1745,7 +1745,7 @@ mod usages_bundle_tests {
std::fs::write(dir.path().join(name), b"old").unwrap();
}
let jar = super::jvm_inspect_bundle(dir.path()).unwrap();
assert_eq!(jar, dir.path().join("jvm-inspect-1.1.0.jar"));
assert_eq!(jar, dir.path().join("jvm-inspect-1.1.1.jar"));
assert_eq!(std::fs::read(&jar).unwrap(), include_bytes!("../../../java/jvm-inspect/openidea-jvm-inspect.jar"));
assert!(!dir.path().join("jvm-inspect-0.9.0.jar").exists());
assert_eq!(std::fs::read(dir.path().join("java-usages-1.7.0.jar")).unwrap(), b"old");
+17 -2
Переглянути файл
@@ -1155,16 +1155,31 @@ fn check_rev(rev: &str) -> IdeResult<&str> {
Ok(rev)
}
/// The short name of a full branch ref (`refs/heads/x`, `refs/remotes/origin/x`) when it
/// names that same branch: git writes the name it is given into the merge message and the
/// reflog. A name a tag shares stays a full ref, the case IDEA also passes in full.
fn unambiguous_branch_name<'a>(r: &Repo, rev: &'a str) -> &'a str {
let Some(short) = rev.strip_prefix("refs/heads/").or_else(|| rev.strip_prefix("refs/remotes/")) else {
return rev;
};
// An ambiguous name prints nothing (git reports it on stderr).
let full = cli::run_raw(r.root(), &["rev-parse", "--verify", "-q", "--symbolic-full-name", short], None);
match full {
Ok(out) if out.code == Some(0) && out.stdout_str().trim() == rev => short,
_ => rev,
}
}
/// Local changes are stashed and restored around the merge (IDEA's "save local changes").
pub(crate) fn merge(r: &Repo, branch: &str) -> IdeResult<()> {
let branch = check_rev(branch)?;
let branch = unambiguous_branch_name(r, check_rev(branch)?);
crate::preserve::around(r, "Local changes saved before merge", || {
run(r.root(), &["merge", "--no-edit", branch], None).map(|_| ())
})
}
pub(crate) fn rebase(r: &Repo, onto: &str) -> IdeResult<()> {
let onto = check_rev(onto)?;
let onto = unambiguous_branch_name(r, check_rev(onto)?);
crate::preserve::around(r, "Local changes saved before rebase", || {
run(r.root(), &["rebase", onto], None).map(|_| ())
})
+31
Переглянути файл
@@ -505,6 +505,37 @@ fn rebase_and_merge_onto_a_branch_named_like_a_tag_use_the_branch() {
assert_eq!(fx.head(), tip, "fast-forwarded to the branch, not the tag");
}
#[test]
fn merge_and_rebase_record_the_branch_name_git_would_show() {
let (fx, _bare) = Fixture::with_origin();
fx.git(&["switch", "-q", "-c", "topic"]);
fx.write("t.txt", "t\n");
fx.commit_all("topic");
fx.git(&["push", "-q", "origin", "topic"]);
fx.git(&["switch", "-q", "main"]);
fx.write("m.txt", "m\n");
fx.commit_all("main");
let repo = fx.repo();
let subject = || fx.git(&["log", "-1", "--format=%s"]);
repo.merge("refs/heads/topic").unwrap();
assert_eq!(subject(), "Merge branch 'topic'");
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
repo.merge("refs/remotes/origin/topic").unwrap();
assert_eq!(subject(), "Merge remote-tracking branch 'origin/topic'");
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
repo.rebase("refs/heads/topic").unwrap();
let reflog = fx.git(&["reflog", "--format=%gs"]);
assert!(reflog.contains("rebase (start): checkout topic"), "{reflog}");
fx.git(&["reset", "-q", "--hard", "ORIG_HEAD"]);
// A tag of the same name makes the short name ambiguous: the full ref stays.
fx.git(&["tag", "topic", "main~1"]);
repo.merge("refs/heads/topic").unwrap();
assert_eq!(subject(), "Merge branch 'refs/heads/topic'");
}
#[test]
fn interactive_rebase_edit_stops_for_amend() {
let (fx, ids) = linear();
+88
Переглянути файл
@@ -0,0 +1,88 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openSaveActions(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("Optimize imports");
await settings.getByRole("treeitem", { name: "Actions on Save", exact: true }).click();
await search.clear();
return settings;
}
test("Actions on Save aligns each enabled action with its trigger in wide and narrow panes", async ({
workbench: page,
}) => {
const settings = await openSaveActions(page);
const table = settings.getByRole("table", { name: "Actions on Save", exact: true });
const action = table.getByRole("columnheader", { name: "Action", exact: true });
const heading = table.getByRole("columnheader", { name: "Activated on", exact: true });
const format = table.getByRole("row", { name: /Reformat code/ });
const imports = table.getByRole("row", { name: /Optimize imports/ });
const cleanup = table.getByRole("row", { name: /Run code cleanup/ });
const trigger = (action: typeof format) => action.getByRole("cell").nth(1);
await expect(table.getByRole("row")).toHaveCount(4);
await format.getByRole("checkbox").check();
await imports.getByRole("checkbox").press("Space");
await expect(trigger(format)).toHaveText("Save or Save All");
await expect(trigger(imports)).toHaveText("Save or Save All");
await expect(trigger(cleanup)).toBeEmpty();
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 740 });
await expect(heading).toBeInViewport({ ratio: 1 });
await expect(trigger(imports)).toBeInViewport({ ratio: 1 });
const column = (await heading.boundingBox())!;
expect((await action.boundingBox())!.width).toBeGreaterThan(column.width);
expect(
await trigger(imports).evaluate((cell) => {
const range = document.createRange();
range.selectNodeContents(cell.firstElementChild!);
return range.getClientRects().length;
}),
).toBe(1);
for (const row of [format, imports, cleanup]) {
const cell = (await trigger(row).boundingBox())!;
expect(Math.abs(column.x - cell.x)).toBeLessThan(1);
expect(Math.abs(column.width - cell.width)).toBeLessThan(1);
}
expect(await table.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
await expect(settings.getByRole("button", { name: "Editor › General", exact: true })).toBeInViewport();
}
await format.getByRole("checkbox").uncheck();
await expect(trigger(format)).toBeEmpty();
await expect(trigger(imports)).toHaveText("Save or Save All");
});
test("Actions on Save stages the same preferences as Editor General and honors Apply and Cancel", async ({
workbench: page,
}) => {
const settings = await openSaveActions(page);
const format = settings.getByRole("checkbox", { name: "Reformat code", exact: true });
const imports = settings.getByRole("checkbox", { name: "Optimize imports", exact: true });
const cleanup = settings.getByRole("checkbox", { name: "Run code cleanup", exact: true });
const apply = settings.getByRole("button", { name: "Apply", exact: true });
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
await format.check();
await imports.check();
await settings.getByRole("button", { name: "Editor › General", exact: true }).click();
await expect(settings.getByRole("checkbox", { name: "Reformat code on save", exact: true })).toBeChecked();
await settings.getByRole("button", { name: "Back", exact: true }).click();
await expect(format).toBeChecked();
await expect(imports).toBeChecked();
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openSaveActions(page);
await expect(format).toBeChecked();
await expect(imports).toBeChecked();
await cleanup.check();
await cancel.click();
await openSaveActions(page);
await expect(cleanup).not.toBeChecked();
await expect(format).toBeChecked();
await expect(imports).toBeChecked();
});
+80
Переглянути файл
@@ -0,0 +1,80 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openCompletionSettings(page: Page) {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
const search = dialog.getByRole("textbox", { name: "Search settings" });
await search.fill("First letter only");
await dialog.getByRole("treeitem", { name: "Code Completion", exact: true }).click();
await search.clear();
return dialog;
}
test("Code Completion puts both case-matching choices beside the checkbox and keeps them in view", async ({
workbench: page,
}) => {
await page.setViewportSize({ width: 1120, height: 740 });
const dialog = await openCompletionSettings(page);
const matchCase = dialog.getByRole("checkbox", { name: "Match case:", exact: true });
const choices = dialog.getByRole("radiogroup", { name: "Match case:", exact: true });
const first = choices.getByRole("radio", { name: "First letter only", exact: true });
const all = choices.getByRole("radio", { name: "All letters", exact: true });
await expect(first).toBeChecked();
await expect(all).not.toBeChecked();
const matchBox = (await matchCase.boundingBox())!;
const firstBox = (await first.boundingBox())!;
const allBox = (await all.boundingBox())!;
expect(Math.abs(matchBox.y - firstBox.y)).toBeLessThan(1);
expect(Math.abs(firstBox.y - allBox.y)).toBeLessThan(1);
expect(firstBox.x).toBeGreaterThan(matchBox.x + matchBox.width);
expect(allBox.x).toBeGreaterThan(firstBox.x + firstBox.width);
for (const width of [580, 520]) {
await page.setViewportSize({ width, height: 740 });
await expect(matchCase).toBeInViewport({ ratio: 1 });
await expect(first).toBeInViewport({ ratio: 1 });
await expect(all).toBeInViewport({ ratio: 1 });
await expect(dialog.getByText("All letters", { exact: true })).toBeInViewport({ ratio: 1 });
}
});
test("Code Completion preserves case and popup delay preferences across Apply and Cancel", async ({
workbench: page,
}) => {
const dialog = await openCompletionSettings(page);
const matchCase = dialog.getByRole("checkbox", { name: "Match case:", exact: true });
const first = dialog.getByRole("radio", { name: "First letter only", exact: true });
const all = dialog.getByRole("radio", { name: "All letters", exact: true });
await matchCase.uncheck();
await expect(first).toBeDisabled();
await expect(all).toBeDisabled();
await expect(first).toBeChecked();
await matchCase.check();
await first.press("ArrowRight");
await expect(all).toBeChecked();
const docs = dialog.getByRole("textbox", { name: "Show the documentation popup in", exact: true });
const params = dialog.getByRole("textbox", { name: "Show the parameter info popup in", exact: true });
await dialog.getByRole("checkbox", { name: "Show the documentation popup in", exact: true }).check();
await dialog.getByRole("checkbox", { name: "Show the parameter info popup in", exact: true }).check();
await docs.fill("750");
await params.fill("1250");
const apply = dialog.getByRole("button", { name: "Apply", exact: true });
const cancel = dialog.getByRole("button", { name: "Cancel", exact: true });
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openCompletionSettings(page);
await expect(all).toBeChecked();
await expect(docs).toHaveValue("750");
await expect(params).toHaveValue("1250");
await matchCase.uncheck();
await expect(all).toBeDisabled();
await expect(all).toBeChecked();
await cancel.click();
await openCompletionSettings(page);
await expect(matchCase).toBeChecked();
await expect(all).toBeChecked();
});
+71
Переглянути файл
@@ -0,0 +1,71 @@
import { expect, openFromTree, test } from "./fixtures";
test("code folding controls stay grouped in narrow settings", async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
const label = "Show code folding outline";
const outline = dialog.getByRole("checkbox", { name: label, exact: true });
const visibility = dialog.getByRole("button", { name: label, exact: true });
const defaults = dialog.getByRole("region", { name: "Fold by default:", exact: true });
await expect(visibility).toHaveText("On hover");
const wideOutline = (await outline.boundingBox())!;
expect((await visibility.boundingBox())!.x).toBeGreaterThan(wideOutline.x + wideOutline.width);
await page.setViewportSize({ width: 520, height: 760 });
await expect(visibility).toBeInViewport({ ratio: 0.98 });
const rows = await Promise.all(
["File header", "Imports", "Documentation comments"].map((name) =>
defaults.getByRole("checkbox", { name, exact: true }).boundingBox(),
),
);
expect(rows[0]!.x).toBe(rows[2]!.x);
expect(rows[0]!.y).toBeLessThan(rows[1]!.y);
expect(rows[1]!.y).toBeLessThan(rows[2]!.y);
await outline.uncheck();
await expect(dialog.getByRole("textbox", { name: label, exact: true })).toBeDisabled();
await expect(defaults.getByRole("checkbox", { name: "Imports", exact: true })).toBeEnabled();
});
test("folding visibility applies to an already open editor and keeps folded arrows visible", async ({
workbench: page,
}) => {
const editor = await openFromTree(page, "App.tsx");
const content = editor.locator(".cm-content");
await content.click();
await page.keyboard.press("Meta+a");
await page.keyboard.insertText("export function sum() {\n return 1 + 2;\n}\n");
const arrow = editor.locator(".cm-foldGutter .cm-openidea-foldOpen").first();
await expect(arrow).toHaveCSS("opacity", "0");
const openSettings = async () => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
return dialog;
};
const label = "Show code folding outline";
const settings = await openSettings();
await settings.getByRole("button", { name: label, exact: true }).click();
await page.getByRole("option", { name: "Always", exact: true }).click();
await settings.getByRole("button", { name: "OK", exact: true }).click();
await content.hover();
await expect(arrow).toHaveCSS("opacity", "1");
const reopened = await openSettings();
const control = reopened.getByRole("button", { name: label, exact: true });
await expect(control).toHaveText("Always");
await control.click();
await page.getByRole("option", { name: "On hover", exact: true }).click();
await reopened.getByRole("button", { name: "OK", exact: true }).click();
await content.hover();
await expect(arrow).toHaveCSS("opacity", "0");
await arrow.click();
await content.hover();
await expect(editor.locator(".cm-foldGutter .cm-openidea-foldClosed").first()).toHaveCSS("opacity", "1");
await expect(editor.locator(".cm-foldPlaceholder").first()).toBeVisible();
});
+3 -2
Переглянути файл
@@ -2,7 +2,8 @@ import { expect, stubDesktop, test } from "./fixtures";
const amountName = "regionalSettlementAmountFromExternalProcessorBeforeRounding";
const routingName = "settlementRoutingReferenceForCrossBorderReconciliation";
const routingValue = "'APR-2026 / eu-west / batch-701 / settlement complete'";
const routingText = "APR-2026 / eu-west / batch-701 / settlement complete";
const routingValue = "'" + routingText + "'";
test("keeps values and their full-value action readable in a narrow debugger", async ({ workbench: page }) => {
await page.setViewportSize({ width: 1220, height: 760 });
@@ -46,7 +47,7 @@ test("keeps values and their full-value action readable in a narrow debugger", a
await expect(show).toBeInViewport({ ratio: 1 });
await show.click();
const dialog = page.getByRole("dialog", { name: `Value of ${routingName}` });
await expect(dialog.getByText(routingValue, { exact: true })).toBeVisible();
await expect(dialog.getByText(routingText, { exact: true })).toBeVisible();
await page.keyboard.press("Escape");
await expect(dialog).toBeHidden();
+87
Переглянути файл
@@ -0,0 +1,87 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openGeneral(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("File patterns");
await settings.getByRole("treeitem", { name: "General", exact: true }).click();
await search.clear();
return settings;
}
test("Editor General fits the soft-wrap pattern field and stacks the scrolling choices", async ({
workbench: page,
}) => {
await page.setViewportSize({ width: 1120, height: 850 });
const settings = await openGeneral(page);
const softWraps = settings.getByRole("region", { name: "Soft Wraps", exact: true });
const wrap = softWraps.getByRole("checkbox", { name: "Soft-wrap files", exact: true });
const patterns = softWraps.getByRole("textbox", { name: "File patterns" });
const scrolling = settings.getByRole("region", { name: "Scrolling", exact: true });
const virtualSpace = settings.getByRole("region", { name: "Virtual Space", exact: true });
const caretPrompt = scrolling.getByText("When caret is moved", { exact: true });
const center = scrolling.getByRole("radio", { name: /keep caret line centered/ });
const minimize = scrolling.getByRole("radio", { name: /minimize editor scrolling/ });
await expect(patterns).toBeVisible();
const toggle = (await wrap.boundingBox())!;
const field = (await patterns.boundingBox())!;
expect(toggle.y).toBeGreaterThan(field.y);
expect(toggle.y + toggle.height).toBeLessThan(field.y + field.height);
expect(field.x).toBeGreaterThan(toggle.x + toggle.width);
expect(await patterns.getAttribute("aria-describedby")).toBeTruthy();
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 850 });
await patterns.scrollIntoViewIfNeeded();
await expect(patterns).toBeInViewport({ ratio: 0.99 });
const fieldBox = (await patterns.boundingBox())!;
const indent = softWraps.getByRole("checkbox", { name: "Use original line's indent for wrapped parts" });
expect((await indent.boundingBox())!.y).toBeGreaterThan(fieldBox.y + fieldBox.height);
expect(await scrolling.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
expect((await scrolling.boundingBox())!.y).toBeGreaterThan((await virtualSpace.boundingBox())!.y);
const first = (await center.boundingBox())!;
const second = (await minimize.boundingBox())!;
expect(first.x).toBeGreaterThan((await caretPrompt.boundingBox())!.x);
expect(second.y).toBeGreaterThan(first.y + first.height);
expect(Math.abs(first.x - second.x)).toBeLessThan(1);
}
});
test("Editor General keeps wheel and wrap dependencies and saves the selected values", async ({ workbench: page }) => {
const settings = await openGeneral(page);
const zoom = settings.getByRole("checkbox", { name: "Change font size with Ctrl/Command+Mouse Wheel" });
const active = settings.getByRole("radio", { name: "Active editor", exact: true });
const all = settings.getByRole("radio", { name: "All editors", exact: true });
const wrap = settings.getByRole("checkbox", { name: "Soft-wrap files", exact: true });
const patterns = settings.getByRole("textbox", { name: "File patterns", exact: true });
const indent = settings.getByRole("checkbox", { name: "Use original line's indent for wrapped parts" });
const apply = settings.getByRole("button", { name: "Apply", exact: true });
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
await zoom.uncheck();
await expect(active).toBeDisabled();
await expect(all).toBeDisabled();
await zoom.check();
await expect(active).toBeChecked();
await active.focus();
await page.keyboard.press("ArrowDown");
await expect(all).toBeChecked();
await wrap.uncheck();
await expect(patterns).toBeDisabled();
await expect(indent).toBeDisabled();
await wrap.check();
await expect(indent).toBeEnabled();
await patterns.fill("*.md; *.notes");
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openGeneral(page);
await expect(zoom).toBeChecked();
await expect(all).toBeChecked();
await expect(wrap).toBeChecked();
await expect(patterns).toHaveValue("*.md; *.notes");
});
+88
Переглянути файл
@@ -0,0 +1,88 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openFileColors(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("Use in project view");
await settings.getByRole("treeitem", { name: "File Colors", exact: true }).click();
await search.clear();
return settings;
}
test("File Colors fits its switches and keeps the toolbar and table headings in view", async ({ workbench: page }) => {
await page.setViewportSize({ width: 1120, height: 760 });
const settings = await openFileColors(page);
const table = settings.getByRole("table", { name: "File colors", exact: true });
const scope = table.getByRole("columnheader", { name: "Scope", exact: true });
const color = table.getByRole("columnheader", { name: "Color", exact: true });
const toolbar = settings.getByRole("toolbar", { name: "File colors actions", exact: true });
const master = settings.getByRole("checkbox", { name: "Enable file colors", exact: true });
const project = settings.getByRole("checkbox", { name: "Use in project view", exact: true });
const hex = settings.getByRole("textbox", { name: "Custom colour hex", exact: true });
await expect(scope).toBeVisible();
expect(Math.abs((await master.boundingBox())!.y - (await project.boundingBox())!.y)).toBeLessThan(1);
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 760 });
await expect(project).toBeInViewport({ ratio: 1 });
await expect(color).toBeInViewport({ ratio: 1 });
await expect(hex).toBeInViewport({ ratio: 1 });
expect((await hex.boundingBox())!.width).toBeGreaterThan(70);
expect((await color.boundingBox())!.width).toBeGreaterThan(80);
const cell = table.getByRole("cell", { name: "Green", exact: true });
expect(Math.abs((await color.boundingBox())!.x - (await cell.boundingBox())!.x)).toBeLessThan(1);
}
const add = toolbar.getByRole("button", { name: "Add", exact: true });
for (let i = 0; i < 10; i++) await add.click();
const last = table.getByRole("row").last();
await expect(last.getByRole("button")).toHaveAttribute("aria-pressed", "true");
await expect(last).toBeInViewport({ ratio: 1 });
await expect(scope).toBeInViewport({ ratio: 1 });
await expect(toolbar).toBeInViewport({ ratio: 1 });
});
test("File Colors preserves ordered rules and placement settings across Apply and Cancel", async ({
workbench: page,
}) => {
const settings = await openFileColors(page);
const table = settings.getByRole("table", { name: "File colors", exact: true });
const tests = table.getByRole("button", { name: "Tests", exact: true });
const firstRule = table.getByRole("row").nth(1);
const toolbar = settings.getByRole("toolbar", { name: "File colors actions", exact: true });
const tabs = settings.getByRole("checkbox", { name: "Use in editor tabs", exact: true });
const master = settings.getByRole("checkbox", { name: "Enable file colors", exact: true });
const apply = settings.getByRole("button", { name: "Apply", exact: true });
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
await tabs.uncheck();
await master.uncheck();
await expect(tabs).toBeDisabled();
await master.check();
await expect(tabs).not.toBeChecked();
await expect(tabs).toBeEnabled();
await tests.press("Enter");
await expect(tests).toHaveAttribute("aria-pressed", "true");
await settings.getByRole("textbox", { name: "Custom colour hex", exact: true }).fill("#1258a5");
await toolbar.getByRole("button", { name: "Move Up", exact: true }).click();
await expect(firstRule.getByRole("button", { name: "Tests", exact: true })).toBeVisible();
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openFileColors(page);
await expect(tabs).not.toBeChecked();
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
const remove = toolbar.getByRole("button", { name: "Remove", exact: true });
await remove.click();
await remove.click();
await expect(table.getByText("No file colors. Click + to add one.", { exact: true })).toBeVisible();
await expect(remove).toBeDisabled();
await cancel.click();
await openFileColors(page);
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
});
+80
Переглянути файл
@@ -0,0 +1,80 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openPostfixSettings(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("Postfix Completion");
await settings.getByRole("treeitem", { name: "Postfix Completion", exact: true }).click();
await search.clear();
return settings;
}
test("Postfix Completion pairs the template list with a responsive code preview", async ({ workbench: page }) => {
await page.setViewportSize({ width: 1120, height: 760 });
const settings = await openPostfixSettings(page);
const list = settings.getByRole("list", { name: "Postfix templates", exact: true });
const preview = settings.getByRole("region", { name: "Template preview", exact: true });
const before = preview.locator("pre").first();
const after = preview.locator("pre").last();
await expect(before).toHaveText("expr.if");
await expect(after).toContainText("if (expr)");
const listBounds = (await list.boundingBox())!;
const widePreview = (await preview.boundingBox())!;
expect(widePreview.x).toBeGreaterThanOrEqual(listBounds.x + listBounds.width);
expect(widePreview.y).toBeLessThan(listBounds.y);
await list.getByRole("button", { name: ".if", exact: true }).press("ArrowDown");
const elseTemplate = list.getByRole("button", { name: ".else", exact: true });
await expect(elseTemplate).toBeFocused();
await expect(elseTemplate).toHaveAttribute("aria-pressed", "true");
await expect(before).toHaveText("expr.else");
await expect(after).toContainText("if (!expr)");
await page.setViewportSize({ width: 520, height: 760 });
await settings.getByRole("tab", { name: "Python", exact: true }).click();
await expect(before).toHaveText("expr.if");
await expect(after).toContainText("if expr:");
await after.scrollIntoViewIfNeeded();
await expect(after).toBeInViewport({ ratio: 0.99 });
const narrowList = (await list.boundingBox())!;
const narrowPreview = (await preview.boundingBox())!;
expect(narrowPreview.y).toBeGreaterThanOrEqual(narrowList.y + narrowList.height);
expect(Math.abs(narrowList.x - narrowPreview.x)).toBeLessThan(2);
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
await settings.getByRole("tab", { name: "JavaScript / TypeScript", exact: true }).click();
await expect(elseTemplate).toHaveAttribute("aria-pressed", "true");
await expect(before).toHaveText("expr.else");
await settings.getByRole("tab", { name: "Java", exact: true }).click();
await list.getByRole("button", { name: ".var", exact: true }).click();
await expect(preview.getByText("Fallback expansion", { exact: true })).toBeVisible();
await expect(after).toContainText("var value = expr;");
});
test("Postfix Completion keeps template selection separate from enabled preferences", async ({ workbench: page }) => {
const settings = await openPostfixSettings(page);
const master = settings.getByRole("checkbox", { name: "Enable postfix completion", exact: true });
const expand = settings.getByRole("checkbox", { name: "Expand templates with Tab", exact: true });
const ifEnabled = settings.getByRole("checkbox", { name: "Enable .if", exact: true });
const preview = settings.getByRole("region", { name: "Template preview", exact: true });
const before = preview.locator("pre").first();
await settings.getByRole("button", { name: ".else", exact: true }).click();
await expect(ifEnabled).toBeChecked();
await ifEnabled.uncheck();
await expect(before).toHaveText("expr.if");
await master.uncheck();
await expect(expand).toBeDisabled();
await expect(ifEnabled).toBeDisabled();
await settings.getByRole("button", { name: ".else", exact: true }).click();
await expect(before).toHaveText("expr.else");
await master.check();
await expect(ifEnabled).not.toBeChecked();
await settings.getByRole("button", { name: "OK", exact: true }).click();
await openPostfixSettings(page);
await expect(ifEnabled).not.toBeChecked();
await expect(master).toBeChecked();
});
+2 -2
Переглянути файл
@@ -82,7 +82,7 @@ test("Quick Evaluate opens an object tree that fits the editor and returns focus
await expect(hint.getByRole("tree")).toHaveCount(0);
await expect(hint).toHaveText(/subtotal\s*=\s*42/);
expect(await ipcCalls(page, "debug_evaluate_in")).toEqual([
{ session: 91, frameId: 11, expression: "summary", context: "hover" },
{ session: 91, frameId: 11, expression: "subtotal", context: "hover" },
{ session: 91, frameId: 11, expression: "summary", context: "watch" },
{ session: 91, frameId: 11, expression: "subtotal", context: "watch" },
]);
});
+4 -3
Переглянути файл
@@ -184,6 +184,7 @@ test("Language Servers page installs a tool with progress (in-memory installer)"
test("font picker supports manual families and CJK fallback in browser development", async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings" });
const preview = dialog.getByRole("textbox", { name: "Font preview", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Typography Settings");
await dialog.getByRole("treeitem", { name: "Font", exact: true }).click();
const family = dialog.getByRole("combobox", { name: "Font", exact: true });
@@ -201,16 +202,16 @@ test("font picker supports manual families and CJK fallback in browser developme
await family.fill("Inter");
await family.press("Enter");
// Computed styles drop redundant quotes around single-token families ("Inter" -> Inter).
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /^Inter, "Inter Variable",/);
await expect(preview).toHaveCSS("font-family", /^Inter, "Inter Variable",/);
const fallback = dialog.getByRole("combobox", { name: "Fallback font", exact: true });
await family.fill("Maple Mono NF");
await family.press("Enter");
await fallback.fill("Inter");
await fallback.press("Enter");
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
await expect(preview).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
await fallback.fill("思源宋体");
await fallback.press("Enter");
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /思源宋体/);
await expect(preview).toHaveCSS("font-family", /思源宋体/);
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
await expect(dialog).toBeHidden();
});
+67
Переглянути файл
@@ -0,0 +1,67 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openSmartKeys(page: Page) {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Smart Keys");
await dialog.getByRole("treeitem", { name: "Smart Keys", exact: true }).click();
return dialog;
}
test("backspace and paste controls align below Enter options in Smart Keys", async ({ workbench: page }) => {
const dialog = await openSmartKeys(page);
const enter = dialog.getByRole("region", { name: "Enter", exact: true });
const unindent = dialog.getByRole("button", { name: /^Unindent(?: on Backspace)?$/ });
const paste = dialog.getByRole("button", { name: "Reformat on paste", exact: true });
const escape = dialog.getByRole("checkbox", { name: "Escape text on paste in string literals", exact: true });
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 760 });
await expect(unindent).toBeInViewport({ ratio: 0.98 });
await expect(paste).toBeInViewport({ ratio: 0.98 });
const enterBox = (await enter.boundingBox())!;
const unindentBox = (await unindent.boundingBox())!;
const pasteBox = (await paste.boundingBox())!;
expect(unindentBox.y).toBeGreaterThan(enterBox.y + enterBox.height);
expect(pasteBox.y).toBeGreaterThanOrEqual(unindentBox.y + unindentBox.height);
expect(Math.abs(pasteBox.x - unindentBox.x)).toBeLessThan(1);
expect((await escape.boundingBox())!.y).toBeGreaterThanOrEqual(pasteBox.y + pasteBox.height);
}
await paste.click();
await expect(page.getByRole("option", { name: "Indent Each Line", exact: true })).toBeInViewport();
});
test("Smart Keys keeps backspace and paste preferences independent across Apply and Cancel", async ({
workbench: page,
}) => {
const setOption = async (label: string, option: string) => {
await page
.getByRole("dialog", { name: "Settings", exact: true })
.getByRole("button", { name: label, exact: true })
.click();
await page.getByRole("option", { name: option, exact: true }).click();
};
const dialog = await openSmartKeys(page);
await setOption("Unindent on Backspace", "To nearest indent position");
await setOption("Reformat on paste", "Indent Block");
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
const reopened = await openSmartKeys(page);
await expect(reopened.getByRole("button", { name: "Unindent on Backspace", exact: true })).toHaveText(
"To nearest indent position",
);
await expect(reopened.getByRole("button", { name: "Reformat on paste", exact: true })).toHaveText("Indent Block");
await setOption("Reformat on paste", "None");
await reopened.getByRole("button", { name: "Cancel", exact: true }).click();
const final = await openSmartKeys(page);
await expect(final.getByRole("button", { name: "Unindent on Backspace", exact: true })).toHaveText(
"To nearest indent position",
);
await expect(final.getByRole("button", { name: "Reformat on paste", exact: true })).toHaveText("Indent Block");
});
+1 -1
Переглянути файл
@@ -2,7 +2,7 @@ Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: OpenIDEA JVM inspect
Bundle-SymbolicName: ai.openidea.jvminspect;singleton:=true
Bundle-Version: 1.1.0
Bundle-Version: 1.1.1
Bundle-RequiredExecutionEnvironment: JavaSE-21
Require-Bundle: org.eclipse.jdt.ls.core,org.eclipse.core.runtime,
org.eclipse.equinox.common,org.eclipse.jdt.debug,org.eclipse.core.resources
+8 -1
Переглянути файл
@@ -123,6 +123,13 @@ ordinary `executeCommand` error.
invoke go on (ide-dap does that unseen while the trace runs).
The outcome is forced into the frame before it is pinned, so the pending return keeps it reachable;
should it be collected before that, the program gets the cancel exception and the trace fails.
- An exception the terminal threw (the cancel exception of `abort` included) ends the client's
`stepOut` in the program's catch. Nothing catching it, the thread would die with no stop left to
`collect` in, so before parking the bundle adds an uncaught-exception request on the thread,
suspending it: the step-out ends at that throw instead, as a java-debug `exception` stop, and a
resume lets the exception end the thread as it would have. Skipped when an enabled request of
java-debug's already reports uncaught throws of that type (one stop, not two). `collect` deletes it;
after `collect` a release no longer resumes the parked event, since that stop keeps the parked frames.
- `wait` returns as soon as the trace leaves `running`, or after `ms`, at most 30 000. While the
terminal runs it also checks every 500 ms whether the VM began to shut down
(`jdk.internal.misc.VM.initLevel`): `System.exit` in a lambda makes the VM wait forever to report
@@ -204,7 +211,7 @@ Java 21. The recorder is compiled by the `javac` on `PATH` with `--release 8`, s
run Java 8. Build twice and compare: two builds of the checked-in jar gave
```
22980a16bd8e303d67ed2e04d76d8974f2d3981120c26e6d9afa47ba361b1503 openidea-jvm-inspect.jar
4ab30723afe1254b991d9457ea66271109f397a17b238870572283aad73338ad openidea-jvm-inspect.jar
```
Change `Bundle-Version` whenever the jar changes: OSGi caches bundles by version.
Бінарний файл не відображається.
+64 -1
Переглянути файл
@@ -31,6 +31,8 @@ import com.sun.jdi.event.MethodExitEvent;
import com.sun.jdi.event.VMDeathEvent;
import com.sun.jdi.event.VMDisconnectEvent;
import com.sun.jdi.request.EventRequest;
import com.sun.jdi.request.EventRequestManager;
import com.sun.jdi.request.ExceptionRequest;
import com.sun.jdi.request.MethodEntryRequest;
import com.sun.jdi.request.MethodExitRequest;
import com.sun.jdi.request.StepRequest;
@@ -170,6 +172,10 @@ final class RealRunTrace {
private Value echoValue;
private EventSet parked;
private Method terminalMethod;
/** Stops the thread at a throw of the terminal's that nothing catches; see {@link #watchUncaught}. */
private volatile EventRequest uncaught;
/** {@code collect} ran, so the client's step-out ended in a stop of its own; see {@link #dispose}. */
private volatile boolean steppedOut;
private RealRunTrace(long id, VirtualMachine vm, ThreadReference thread, RealRunPlan plan, int budget, long generation) {
this.id = id;
@@ -514,6 +520,8 @@ final class RealRunTrace {
}
if (outcome instanceof ObjectReference object) keep(pinned(object));
restoreSilencers();
// Before the state moves: the client steps out as soon as it sees the trace parked.
if (kind.equals("threw")) watchUncaught((ObjectReference) outcome);
boolean hold;
synchronized (stateLock) {
terminalKind = kind;
@@ -532,10 +540,61 @@ final class RealRunTrace {
if (hold) {
parked = set;
terminalMethod = method;
} else {
deleteUncaught();
}
return hold;
}
/**
* Worker, before the trace parks on a terminal that threw. The client's step-out ends in the
* program's catch, but an exception nothing catches ends the thread, with no stop left to read the
* records in. This request stops the thread at that throw instead: java-debug reports every
* exception event as a stop. Not when an enabled request of java-debug's already stops there,
* since the throw would then be reported twice.
*/
private void watchUncaught(ObjectReference exception) {
try {
EventRequestManager manager = vm.eventRequestManager();
ReferenceType type = exception.referenceType();
for (ExceptionRequest r : manager.exceptionRequests()) {
if (r.isEnabled() && r.notifyUncaught() && r.getProperty(Silencer.OWN_PROPERTY) == null && covers(r.exception(), type)) {
return;
}
}
ExceptionRequest r = manager.createExceptionRequest(null, false, true);
r.addThreadFilter(thread);
r.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
r.putProperty(Silencer.OWN_PROPERTY, id);
r.enable();
uncaught = r;
} catch (VMDisconnectedException e) {
// nothing left to stop
} catch (RuntimeException e) {
errors.add("watching for an uncaught throw: " + e);
}
}
private static boolean covers(ReferenceType declared, ReferenceType type) {
for (ReferenceType t = type; t != null; t = t instanceof ClassType c ? c.superclass() : null) {
if (declared == null || t.equals(declared)) return true;
}
return false;
}
private void deleteUncaught() {
EventRequest r = uncaught;
if (r == null) return;
uncaught = null;
try {
vm.eventRequestManager().deleteEventRequest(r);
} catch (VMDisconnectedException e) {
// it went with the VM
} catch (RuntimeException e) {
errors.add("deleting the uncaught-throw request: " + e);
}
}
/**
* Worker, right before the terminal's invoke. JDWP holds an interrupt or stop of a thread that is
* handling an event until that event's handler exits, and an invoke runs inside the handler of the
@@ -758,9 +817,11 @@ final class RealRunTrace {
/** Worker: everything the trace holds, a parked thread the client never stepped out included. */
private void dispose() {
if (parked != null) {
if (stillParked()) resume(parked);
// A stop at an uncaught throw of the terminal's keeps the parked frames: resuming would end it behind java-debug.
if (!steppedOut && stillParked()) resume(parked);
parked = null;
}
deleteUncaught();
teardown();
for (ObjectReference o : pinned) {
try {
@@ -996,6 +1057,8 @@ final class RealRunTrace {
if (generation <= this.generation) {
throw new Failure("stale", "collect needs a stop after the trace's, not generation " + generation);
}
steppedOut = true;
deleteUncaught();
handles.begin(generation);
ToLongFunction<ObjectReference> handle = o -> {
long objectId = o.uniqueID();
+91
Переглянути файл
@@ -100,6 +100,9 @@ public class Real {
case "inl": inLambda(); break;
case "abort": abort(); break;
case "twice": abortAfterTrace(); break;
case "U": uncaught(true); break;
case "Ux": uncaught(false); break;
case "Ua": abortUncaught(); break;
case "exit": exit(); break;
case "mid": mid(); break;
case "fn": functionAndData(); break;
@@ -244,6 +247,23 @@ public class Real {
}
}
/** Keeps the VM alive once main has died of an exception. */
static void keeper() {
new Thread(() -> LockSupport.parkNanos(60_000_000_000L), "keeper").start();
}
static void uncaught(boolean keep) {
if (keep) keeper();
List<Integer> u = nums.stream().map(x -> 10 / (x - 4)).collect(Collectors.toList()); // @U
System.out.println("U " + u);
}
static void abortUncaught() {
keeper();
long never = Stream.iterate(1L, x -> x + 1).filter(x -> x < 0).count(); // @Ua
System.out.println("UA none " + never);
}
static void exit() {
List<Integer> e = nums.stream().filter(x -> { // @exit
if (x == 8) System.exit(3);
@@ -1025,6 +1045,77 @@ def real_run_abort_after_a_trace():
dbg.end()
def uncaught_stop(dbg, name, trace, exception):
"""After a terminal that threw what the program does not catch: the step-out ends in one stop at that
throw, the records can be read there, and Resume lets the exception end the thread. False when no
stop came."""
try:
stop = step_out(dbg, 15)
except (TimeoutError, AssertionError) as e:
check(f'{name}: the uncaught throw stops the traced thread', False, repr(e))
return False
check(f'{name}: the uncaught throw stops the traced thread', stop.get('reason') == 'exception', stop)
check(f'{name}: one stop for the throw', no_stop(dbg, 2))
c = ok(stream('collect', dbg, traceId=trace))
t = c['terminal']
check(f'{name}: the terminal threw {exception}', t['kind'] == 'threw' and t['exception'].get('typeName') == exception, t)
check(f'{name}: release keeps the stop', 'ok' in stream('release', dbg, traceId=trace) and top(dbg) is not None)
resume(dbg)
out = output_line(dbg, 'Exception in thread "main" ' + exception)
check(f'{name}: the exception ends the thread as without the trace', out is not None, ''.join(dbg.dap.output)[-300:])
check(f'{name}: no stop after Resume', no_stop(dbg, 2))
return c
@case
def real_run_uncaught_throw():
# `U` keeps the VM alive with another thread; `Ux` exits with main.
for name in ('U', 'Ux'):
dbg = real(name, 'U')
try:
trace, state, _ = run_until_parked(dbg, 'U', steps=(spec('map', 1),), step_kinds=('sync',))
check(f'{name}: parked after the lambda threw', state['state'] == 'parked', state)
c = uncaught_stop(dbg, name, trace, 'java.lang.ArithmeticException')
if c:
collected_ok(name, c, records=['0=5', '1=10', '0=3', '1=-10', '0=8', '1=2', '0=1', '1=-3', '0=4'])
finally:
dbg.end()
@case
def real_run_uncaught_throw_user_filter():
# java-debug's own uncaught-exception request is on: the throw must stop once, not once per request.
dbg = real('U')
try:
dbg.dap.request('setExceptionBreakpoints', {'filters': ['uncaught']})
trace, state, _ = run_until_parked(dbg, 'U', steps=(spec('map', 1),), step_kinds=('sync',))
check('U-filter: parked after the lambda threw', state['state'] == 'parked', state)
uncaught_stop(dbg, 'U-filter', trace, 'java.lang.ArithmeticException')
finally:
dbg.end()
@case
def real_run_uncaught_abort():
dbg = real('Ua')
try:
trace = ok(arm(dbg, at='Ua', root=spec('iterate', 2), steps=(spec('filter', 1),), terminal=spec('count'),
class_filters=('java.util.stream.*',), step_kinds=('sync',)))['traceId']
resume(dbg)
first = ok(stream('wait', dbg, traceId=trace, ms=500))
check('Ua: the endless terminal is running', first['state'] == 'running', first)
r = ok(stream('abort', dbg, traceId=trace, timeout=30))
check('Ua: interrupted or stopped', r.get('state') in ('interrupted', 'stopped'), r)
state = wait_until_done(dbg, trace, 20)
check('Ua: parked after the cancel', state['state'] == 'parked', state)
if state['state'] == 'parked':
c = uncaught_stop(dbg, 'Ua', trace, 'java.lang.RuntimeException')
if c:
check('Ua: the records up to the abort', len(c['records']) > 0, len(c['records']))
finally:
dbg.end()
def next_breakpoint_stops(dbg, name, what):
"""After a trace that ended without parking: the user's breakpoints are back on."""
try:
+2
Переглянути файл
@@ -26,6 +26,8 @@ adapter = "java-debug"
command = "com.microsoft.java.debug.plugin.jar"
transport = "tcp"
install-hint = "Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers › Java Debugger)"
# Its lazy values are toString() of objects whose class overrides it.
resolve-lazy-variables = true
[[language-servers]]
name = "jdtls"
+1
Переглянути файл
@@ -173,6 +173,7 @@ debug_jvm_memory_referrers trusted project_host bin
debug_listen_for_jvm trusted project_host bindings async
debug_pause trusted project_host bindings async
debug_redefine_classes trusted project_host bindings async
debug_resolve_variable trusted project_host bindings async
debug_restart_frame trusted project_host bindings async
debug_resume trusted project_host bindings async
debug_run_to trusted project_host bindings async
+30 -5
Переглянути файл
@@ -373,9 +373,9 @@ export const commands = {
/** Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16). */
debugCompletions: (session: DebugSessionId, frameId: number | null, text: string, line: number, column: number) => typedError<DebugCompletion[], IdeError>(__TAURI_INVOKE("debug_completions", { session, frameId, text, line, column })),
debugDataBreakpointInfo: (session: DebugSessionId, container: number, name: string, frameId: number | null) => typedError<DataBreakpointInfo, IdeError>(__TAURI_INVOKE("debug_data_breakpoint_info", { session, container, name, frameId })),
debugEvaluate: (session: DebugSessionId, frameId: number | null, expression: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_evaluate", { session, frameId, expression })),
debugEvaluate: (session: DebugSessionId, frameId: number | null, expression: string) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_evaluate", { session, frameId, expression })),
/** Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`. */
debugEvaluateIn: (session: DebugSessionId, frameId: number | null, expression: string, context: string | null) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_evaluate_in", { session, frameId, expression, context })),
debugEvaluateIn: (session: DebugSessionId, frameId: number | null, expression: string, context: string | null) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_evaluate_in", { session, frameId, expression, context })),
debugExceptionFilters: () => typedError<SessionExceptionFilters[], IdeError>(__TAURI_INVOKE("debug_exception_filters")),
/** Force Step Over: step over with every breakpoint suspended until the step ends. */
debugForceStepOver: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_force_step_over", { session, threadId })),
@@ -430,6 +430,7 @@ export const commands = {
debugPause: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_pause", { session, threadId })),
/** HotSwap (Reload Changed Classes) in a java-debug session. */
debugRedefineClasses: (session: DebugSessionId) => typedError<HotSwapResult, IdeError>(__TAURI_INVOKE("debug_redefine_classes", { session })),
debugResolveVariable: (session: DebugSessionId, variable: Variable_Deserialize) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_resolve_variable", { session, variable })),
/** Reset Frame (Drop Frame). */
debugRestartFrame: (session: DebugSessionId, frameId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_restart_frame", { session, frameId })),
debugResume: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_resume", { session, threadId })),
@@ -445,7 +446,7 @@ export const commands = {
debugSetExceptionBreakpoints: (choices: { [key in string]: boolean }) => typedError<null, IdeError>(__TAURI_INVOKE("debug_set_exception_breakpoints", { choices })),
/** Method breakpoints (all files); states aligned with `breakpoints`. */
debugSetFunctionBreakpoints: (breakpoints: FunctionBreakpoint[]) => typedError<BreakpointState[], IdeError>(__TAURI_INVOKE("debug_set_function_breakpoints", { breakpoints })),
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
debugStackTrace: (session: DebugSessionId, threadId: number) => typedError<StackFrame[], IdeError>(__TAURI_INVOKE("debug_stack_trace", { session, threadId })),
/** Starts a session owned by this window: its events (and those of child sessions) go here only. */
debugStart: (config: LaunchConfig) => typedError<DebugSessionId, IdeError>(__TAURI_INVOKE("debug_start", { config })),
@@ -471,7 +472,7 @@ export const commands = {
{ kind: "finished" } | null, IdeError>(__TAURI_INVOKE("debug_stream_trace_abort", { session })),
debugThreads: (session: DebugSessionId) => typedError<ThreadInfo[], IdeError>(__TAURI_INVOKE("debug_threads", { session })),
debugUnityProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_unity_processes")),
debugVariables: (session: DebugSessionId, reference: number) => typedError<Variable[], IdeError>(__TAURI_INVOKE("debug_variables", { session, reference })),
debugVariables: (session: DebugSessionId, reference: number) => typedError<Variable_Serialize[], IdeError>(__TAURI_INVOKE("debug_variables", { session, reference })),
dependencyVersions: (doc: DocId, offset: number | null, request: RequestId) => typedError<DependencyVersions[], IdeError>(__TAURI_INVOKE("dependency_versions", { doc, offset, request })),
deployCompare: (path: IpcPath, server: string | null, request: RequestId) => typedError<SyncEntry[], IdeError>(__TAURI_INVOKE("deploy_compare", { path, server, request })),
deployCoverage: (paths: IpcPath[]) => typedError<DeploymentCoverage[], IdeError>(__TAURI_INVOKE("deploy_coverage", { paths })),
@@ -6310,9 +6311,12 @@ export type FoldRange = {
kind: FoldKind,
};
export type FoldingOutlineVisibility = "hover" | "always";
/** Editor › General › Code Folding. */
export type FoldingSettings = {
showOutline?: boolean,
outlineVisibility?: FoldingOutlineVisibility,
fileHeader?: boolean,
imports?: boolean,
docComments?: boolean,
@@ -12380,13 +12384,34 @@ export type UpdateStatus = {
checking: boolean,
};
export type Variable = {
export type Variable = Variable_Serialize | Variable_Deserialize;
export type Variable_Deserialize = {
name: string,
value: string,
typeName: string | null,
/** > 0 when expandable. */
variablesReference: number,
evaluateName: string | null,
/**
* `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
* `variables` returns for `variables_reference` holds the value and its children.
*/
lazy?: boolean,
};
export type Variable_Serialize = {
name: string,
value: string,
typeName: string | null,
/** > 0 when expandable. */
variablesReference: number,
evaluateName: string | null,
/**
* `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
* `variables` returns for `variables_reference` holds the value and its children.
*/
lazy?: boolean,
};
/** Version Control › Confirmation. */
+2 -12
Переглянути файл
@@ -68,6 +68,7 @@ import { cloneCaretAbove, cloneCaretBelow } from "./cm/verticalMotion";
import { pasteAsPlainText, pasteFromHistory, unwrapAtCaret } from "./extras";
import { cyclicExpandWord } from "./wordCompletion";
import { copyReferenceToClipboard, declaredName, qualifiedReference, referenceOffset } from "./copyReference";
import { selectedLineContext, selectedLines } from "./selectedLines";
import { declarationChain } from "./view/outline";
import { recordClipboard } from "./clipboardHistory";
import { useDocMeta, useOutline } from "./model/document";
@@ -589,15 +590,6 @@ function copyReference(reference: Promise<string>) {
}
}
/** The selected lines (1-based), leaving out the one a selection ends at the start of. */
function selectedLines(state: EditorState): { first: number; last: number } {
const { doc, selection } = state;
const { from, to } = selection.main;
const first = doc.lineAt(from).number;
const last = Math.max(first, doc.lineAt(to).number - (to > from && doc.lineAt(to).from === to ? 1 : 0));
return { first, last };
}
/** `path:12`, or `path:12-18` for a selection over several lines. */
function pathWithLines(state: EditorState, path: string): string {
const { first, last } = selectedLines(state);
@@ -606,11 +598,9 @@ function pathWithLines(state: EditorState, path: string): string {
function copyPathReferencePopup(view: EditorView, slot: EditorSlot) {
const path = slot.model.path;
const { first, last } = selectedLines(view.state);
const contributed = menuGroupItems("copyPath", {
paths: [path],
line: first - 1,
endLine: last > first ? last - 1 : undefined,
...selectedLineContext(view.state),
}).flatMap((item) =>
(item.kind ?? "item") === "item" && "run" in item && item.id && item.run && item.preview
? [
+10 -4
Переглянути файл
@@ -1,7 +1,7 @@
/**
* Folding: ranges from the backend (`doc_folding`, tree-sitter based) merged
* with CodeMirror's syntax folding (`foldNodeProp`) as fallback, IDEA-style
* chevrons in the gutter (open chevrons only on gutter hover).
* chevrons in the gutter (open chevrons can be shown only on hover).
*/
import {
EditorSelection,
@@ -23,6 +23,7 @@ import {
unfoldEffect,
} from "@codemirror/language";
import type { FoldRange } from "@/platform/ipc";
import type { FoldingOutlineVisibility } from "@/bindings";
import { enclosingCodeBlock } from "./caretCommands";
import { regionMarkerAt, regionNameAt } from "./regions";
@@ -432,9 +433,10 @@ export const expandRecursively = (view: EditorView) =>
view.state.selection.ranges.flatMap((r) => expandRecursivelyEffects(view.state, r.head)),
);
function chevron(open: boolean): HTMLElement {
function chevron(open: boolean, visibility: FoldingOutlineVisibility): HTMLElement {
const span = document.createElement("span");
span.className = open ? "cm-openidea-foldOpen" : "cm-openidea-foldClosed";
span.classList.toggle("cm-openidea-foldOnHover", open && visibility === "hover");
span.title = open ? "Collapse" : "Expand";
const ns = "http://www.w3.org/2000/svg";
const svg = document.createElementNS(ns, "svg");
@@ -477,10 +479,14 @@ export function foldChipWidth(el: HTMLElement): number {
return Math.round(chip.getBoundingClientRect().width);
}
export function foldingExtension(showOutline = true): Extension {
export function foldingExtension(showOutline = true, visibility: FoldingOutlineVisibility = "hover"): Extension {
return [
// The chevron column sits right of contributed icon gutters (IDEA new UI).
showOutline ? Prec.lowest(foldGutter({ markerDOM: chevron, foldingChanged: backendFoldingChanged })) : [],
showOutline
? Prec.lowest(
foldGutter({ markerDOM: (open) => chevron(open, visibility), foldingChanged: backendFoldingChanged }),
)
: [],
backendFolds,
backendFoldService,
codeFolding({
+2 -1
Переглянути файл
@@ -276,7 +276,8 @@ export function distractionFreeExtension(
}
export function foldingFor(settings: EditorSettings | undefined): Extension {
return foldingExtension(prefsOf(settings).folding.showOutline);
const { showOutline, outlineVisibility } = prefsOf(settings).folding;
return foldingExtension(showOutline, outlineVisibility);
}
export function caretFor(settings: EditorSettings | undefined): Extension {
+3 -3
Переглянути файл
@@ -303,9 +303,9 @@ export const openideaTheme = EditorView.theme({
cursor: "pointer",
transition: "opacity var(--dur-fast) var(--ease)",
},
".cm-foldGutter .cm-openidea-foldOpen": { opacity: "0", display: "inline-flex" },
".cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOpen": { opacity: "1" },
".cm-foldGutter .cm-openidea-foldOpen, .cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
".cm-foldGutter .cm-openidea-foldOnHover": { opacity: "0" },
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOnHover": { opacity: "1" },
".cm-foldGutter .cm-gutterElement:hover": { color: "var(--fg-secondary)" },
".cm-foldPlaceholder": {
backgroundColor: "var(--editor-fold-chip)",
+4 -3
Переглянути файл
@@ -115,6 +115,7 @@ import { isClassFile } from "@/platform/classFiles";
import { isVirtualUri, virtualDocument } from "@/platform/virtualDocs";
import type { VirtualDocument } from "@/platform/ipc";
import type { Scheduler } from "./sync/DocSync";
import { selectedLineContext } from "./selectedLines";
export const fileKey = (path: string) => `file:${path}`;
export const fileInput = (path: string): EditorInput => ({ kind: "file", key: fileKey(path), path });
@@ -994,7 +995,7 @@ export class EditorController implements SlotHost {
] as MenuItem[])
: ([
{ kind: "separator" },
openInMenu(slot.model.path, view.state.doc.lineAt(view.state.selection.main.head).number - 1),
openInMenu(slot.model.path, selectedLineContext(view.state)),
{ kind: "separator" },
localHistoryMenu(slot.model.path),
gitMenu(slot.model.path),
@@ -2352,7 +2353,7 @@ export class EditorController implements SlotHost {
}
/** Open In › for a file: Project View, Finder / Explorer / Files, associated app, Terminal. */
function openInMenu(path: string, line?: number): MenuItem {
function openInMenu(path: string, lines?: { line: number; endLine?: number }): MenuItem {
return {
label: "Open In",
submenu: [
@@ -2372,7 +2373,7 @@ function openInMenu(path: string, line?: number): MenuItem {
: []),
{ kind: "action", action: "project.openInTerminal", arg: path, label: "Terminal" },
{ kind: "separator" },
...menuGroupItems("openIn", { paths: [path], line }),
...menuGroupItems("openIn", { paths: [path], ...lines }),
],
};
}
+30
Переглянути файл
@@ -239,6 +239,36 @@ describe("editor Copy Path/Reference chooser", () => {
]);
});
it("gives Open In contributions the selected lines", () => {
const contexts: MenuGroupContext[] = [];
disposers.push(
registerMenuGroup({
id: "test.openIn",
menus: ["openIn"],
items: (_menu, ctx) => {
contexts.push(ctx);
return [];
},
}),
);
const view = ctrl.activeSlot!.view!;
vi.spyOn(view, "posAtCoords").mockReturnValue(null);
// The caret; a selection from the second line back into the first; one ending at the start of the second.
for (const selection of [
{ anchor: documentText.indexOf("A {}") },
{ anchor: documentText.indexOf("A {}"), head: 0 },
{ anchor: 0, head: documentText.indexOf("class") },
]) {
view.dispatch({ selection });
ctrl.onContextMenu(ctrl.activeSlot!, new MouseEvent("contextmenu"));
}
expect(contexts.map(({ paths, line, endLine }) => [paths, line, endLine])).toEqual([
[[path], 1, undefined],
[[path], 0, 1],
[[path], 0, undefined],
]);
});
it("adds the chooser to Copy / Paste Special", () => {
vi.spyOn(ctrl.activeSlot!.view!, "posAtCoords").mockReturnValue(null);
ctrl.onContextMenu(ctrl.activeSlot!, new MouseEvent("contextmenu"));
+16
Переглянути файл
@@ -0,0 +1,16 @@
import type { EditorState } from "@codemirror/state";
/** The main selection's lines (1-based), leaving out the one a selection ends at the start of, as IDEA. */
export function selectedLines(state: EditorState): { first: number; last: number } {
const { doc, selection } = state;
const { from, to } = selection.main;
const first = doc.lineAt(from).number;
const last = Math.max(first, doc.lineAt(to).number - (to > from && doc.lineAt(to).from === to ? 1 : 0));
return { first, last };
}
/** The selected lines as a menu group's 0-based `line` / `endLine` (absent for a single line). */
export function selectedLineContext(state: EditorState): { line: number; endLine?: number } {
const { first, last } = selectedLines(state);
return { line: first - 1, endLine: last > first ? last - 1 : undefined };
}
+2
Переглянути файл
@@ -30,6 +30,7 @@ describe("pending hints", () => {
vi.advanceTimersByTime(PENDING_HINT_DELAY_MS);
expect(hint()).toBe("Waiting…");
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBe("true");
expect(document.querySelector(".cm-lsp-hint .cm-lsp-hint-spinner svg")).not.toBeNull();
done();
expect(hint()).toBeNull();
});
@@ -37,6 +38,7 @@ describe("pending hints", () => {
it("marks only progress as pending", () => {
showHint(view, "Done");
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBeUndefined();
expect(document.querySelector(".cm-lsp-hint-spinner")).toBeNull();
});
it("puts what the hint answers in its data attributes", () => {
+2
Переглянути файл
@@ -7,6 +7,7 @@ import { StateEffect, StateField, type Extension } from "@codemirror/state";
import { EditorView, keymap, showTooltip, type Tooltip } from "@codemirror/view";
import { Prec } from "@codemirror/state";
import { txTemplate } from "@/platform/i18n";
import { spinnerNode } from "@/ui/iconNode";
interface Hint {
pos: number;
@@ -48,6 +49,7 @@ const hintField = StateField.define<Hint | null>({
Object.assign(dom.dataset, h.data);
if (typeof h.content === "string") {
dom.textContent = txTemplate(h.content);
if (h.pending) dom.prepend(spinnerNode(12, "cm-lsp-hint-spinner"));
return { dom };
}
const built = h.content();
+1
Переглянути файл
@@ -335,6 +335,7 @@ export const lspTheme = EditorView.theme({
boxShadow: "var(--shadow-popup)",
whiteSpace: "pre-wrap",
},
".cm-lsp-hint-spinner": { display: "inline-flex", verticalAlign: "-2px", marginRight: "var(--space-2)" },
// The hint is the tooltip element itself: beat the editor theme's `.cm-tooltip` width.
".cm-tooltip.cm-lsp-hint": { maxWidth: "min(480px, 100%)" },
".cm-lsp-hint-error": {
+2 -2
Переглянути файл
@@ -42,7 +42,7 @@ import {
usagesOf,
} from "./stepIndex";
const SCRIPT = /\.(?:[cm]?[jt]sx?|java|kt)$/i;
const SCRIPT = /\.(?:[cm]?[jt]sx?|java|kt|py)$/i;
const FEATURE = /\.feature$/i;
const DELAY_MS = 300;
@@ -168,7 +168,7 @@ export function activate(): () => void {
return targets.length ? { from: step.from, to: step.to, targets } : null;
}
if (!SCRIPT.test(doc.path)) return null;
const definition = stepDefinitions(text).find((d) => d.from <= offset && offset < d.to);
const definition = stepDefinitions(text, doc.path).find((d) => d.from <= offset && offset < d.to);
if (!definition) return null;
const targets = await usagesOf(definition);
return targets.length ? { from: definition.from, to: definition.to, targets } : null;
+137
Переглянути файл
@@ -0,0 +1,137 @@
import { describe, expect, it } from "vitest";
import {
definitionInsertions,
matchesStep,
snippetStyle,
stepDefinitions,
stepSnippet,
type FeatureStep,
} from "./steps";
const step = (text: string): FeatureStep => ({
from: 0,
to: 0,
keyword: "Given ",
type: "Given",
text,
matchText: text,
});
const apply = (text: string, insertions: { at: number; text: string }[]) =>
[...insertions].sort((a, b) => b.at - a.at).reduce((out, i) => out.slice(0, i.at) + i.text + out.slice(i.at), text);
describe("behave steps", () => {
const BEHAVE = `from behave import given, then
@given('an empty cart')
def step_impl(context):
pass
@given(u"a cart with {count:d} items")
def step_impl(context, count):
pass
@then('the total is {amount:f} {currency}')
def step_impl(context, amount, currency):
pass
use_step_matcher("re")
@when(r'^I remove (?P<count>\\d+) items?$')
def step_impl(context, count):
pass
@step("""I check out""")
def step_impl(context):
pass
`;
it("reads parse formats, and regular expressions after use_step_matcher", () => {
const defs = stepDefinitions(BEHAVE, "features/steps/cart_steps.py");
expect(defs.map((d) => d.source)).toEqual([
"an empty cart",
"a cart with {count:d} items",
"the total is {amount:f} {currency}",
"^I remove (?P<count>\\d+) items?$",
"I check out",
]);
const [empty, count, total, remove, checkout] = defs;
expect(BEHAVE.slice(count!.from, count!.to)).toBe('u"a cart with {count:d} items"');
expect(matchesStep(empty!, step("an empty cart"))).toBe(true);
expect(matchesStep(empty!, step("an empty cart now"))).toBe(false);
expect(matchesStep(count!, step("a cart with 3 items"))).toBe(true);
expect(matchesStep(count!, step("a cart with three items"))).toBe(false);
expect(matchesStep(total!, step("the total is 3.50 EUR"))).toBe(true);
expect(matchesStep(remove!, step("I remove 2 items"))).toBe(true);
expect(matchesStep(remove!, step("I remove all items"))).toBe(false);
// `use_step_matcher("re")` stays in effect: a plain string is a regular expression.
expect(matchesStep(checkout!, step("I check out"))).toBe(true);
});
it("writes a pending step_impl and imports the decorator", () => {
expect(snippetStyle("features/steps/cart_steps.py", BEHAVE)).toBe("behave");
const snippet = stepSnippet("When", "I pay {gift} 'now'", "behave");
expect(snippet.text).toBe(
[
"@when('I pay {{gift}} \\'now\\'')",
"def step_impl(context):",
" raise NotImplementedError('STEP: When I pay {gift} \\'now\\'')",
"",
].join("\n"),
);
const { insertions, select } = definitionInsertions(BEHAVE, "When", snippet, "behave");
const out = apply(BEHAVE, insertions);
expect(out.startsWith("from behave import given, then, when\n")).toBe(true);
expect(out.endsWith(` pass\n\n\n${snippet.text}`)).toBe(true);
expect(out.split("\n")[select.line]!.slice(select.from, select.to)).toMatch(/^raise NotImplementedError/);
const created = stepDefinitions(out, "steps.py").find((d) => d.source.startsWith("I pay"))!;
expect(created).toBeDefined();
});
it("matches a created step's braces literally", () => {
const text = `from behave import when\n\n${stepSnippet("When", "I pay {gift}", "behave").text}`;
const [created] = stepDefinitions(text, "steps.py");
expect(matchesStep(created!, step("I pay {gift}"))).toBe(true);
});
});
describe("pytest-bdd steps", () => {
const PYTEST_BDD = `from pytest_bdd import given, parsers, scenarios, when
scenarios("cart.feature")
@given("there are {count} cucumbers")
def literal():
pass
@given(parsers.parse("I have {start:d} cucumbers"), target_fixture="cucumbers")
def start(start):
return start
@when(parsers.re(r"I eat (?P<eat>\\d+) cucumbers"))
def eat(cucumbers, eat):
pass
`;
it("matches plain strings exactly and parsers by their kind", () => {
const [literal, start, eat] = stepDefinitions(PYTEST_BDD, "tests/test_cart.py");
expect(matchesStep(literal!, step("there are {count} cucumbers"))).toBe(true);
expect(matchesStep(literal!, step("there are 5 cucumbers"))).toBe(false);
expect(matchesStep(start!, step("I have 12 cucumbers"))).toBe(true);
expect(matchesStep(eat!, step("I eat 5 cucumbers"))).toBe(true);
expect(matchesStep(eat!, step("I eat 5 cucumbers today"))).toBe(false);
});
it("writes an anonymous pending step", () => {
expect(snippetStyle("tests/test_cart.py", PYTEST_BDD)).toBe("pytest-bdd");
const snippet = stepSnippet("Then", "I have {count} cucumbers", "pytest-bdd");
expect(snippet.text).toBe(
["@then('I have {count} cucumbers')", "def _():", " raise NotImplementedError", ""].join("\n"),
);
const { insertions } = definitionInsertions(PYTEST_BDD, "Then", snippet, "pytest-bdd");
const out = apply(PYTEST_BDD, insertions);
expect(out.startsWith("from pytest_bdd import given, parsers, scenarios, when, then\n")).toBe(true);
const created = stepDefinitions(out, "tests/test_cart.py").at(-1)!;
expect(matchesStep(created, step("I have {count} cucumbers"))).toBe(true);
});
});
+174
Переглянути файл
@@ -0,0 +1,174 @@
/**
* Python step definitions: behave's `@given('…')` decorators (with its `parse`, `cfparse` and
* `re` step matchers, switched by `use_step_matcher`) and pytest-bdd's (plain strings matched
* exactly, `parsers.parse` / `cfparse` / `re`).
*/
import type { StepDefinition } from "./steps";
export type PythonFramework = "behave" | "pytest-bdd";
type Matcher = "parse" | "re" | "string";
/** pytest-bdd when the file imports it; behave otherwise. */
export function pythonFramework(text: string): PythonFramework {
return /^[ \t]*(?:from|import)[ \t]+pytest_bdd\b/m.test(text) ? "pytest-bdd" : "behave";
}
const DECORATOR = /@(?:given|when|then|step|Given|When|Then|Step)\s*\(\s*/g;
const STEP_MATCHER = /\b(?:use_step_matcher|step_matcher)\s*\(\s*["'](\w+)["']\s*\)/g;
const PARSER = /^(?:parsers\.)?(parse|cfparse|re|string)\s*\(\s*/;
/** The step definitions of a Python file. */
export function pythonStepDefinitions(text: string): StepDefinition[] {
const framework = pythonFramework(text);
// behave's matcher in effect from each `use_step_matcher(…)` call on.
const switches = [...text.matchAll(STEP_MATCHER)].map((m) => ({
at: m.index,
matcher: (m[1] === "re" ? "re" : "parse") as Matcher,
}));
const out: StepDefinition[] = [];
for (const m of text.matchAll(DECORATOR)) {
let at = m.index + m[0].length;
let matcher: Matcher =
framework === "pytest-bdd" ? "string" : (switches.filter((s) => s.at < m.index).pop()?.matcher ?? "parse");
const parser = PARSER.exec(text.slice(at, at + 32));
if (parser) {
matcher = parser[1] === "re" ? "re" : parser[1] === "string" ? "string" : "parse";
at += parser[0].length;
}
const literal = readPythonString(text, at);
if (!literal) continue;
const regexp = matcherRegExp(literal.value, matcher);
if (regexp) out.push({ from: at, to: literal.end, source: literal.value, regexp });
}
return out;
}
/** A string literal at `at` (an `r`/`u`/`b` prefix and triple quotes included), without f-strings. */
export function readPythonString(text: string, at: number): { value: string; end: number } | null {
const prefix = /^[rRuUbB]{0,2}/.exec(text.slice(at, at + 2))![0];
const raw = /r/i.test(prefix);
let i = at + prefix.length;
const quote = text[i];
if (quote !== "'" && quote !== '"') return null;
const triple = text.startsWith(quote.repeat(3), i);
const close = triple ? quote.repeat(3) : quote;
i += close.length;
let value = "";
for (; i < text.length; i++) {
if (text.startsWith(close, i)) return { value, end: i + close.length };
const c = text[i]!;
if (c === "\\" && i + 1 < text.length) {
const next = text[i + 1]!;
// Raw strings keep the backslash; others resolve the escapes a pattern can contain.
value += raw ? c + next : next === "\\" || next === "'" || next === '"' ? next : next === "n" ? "\n" : c + next;
i++;
} else if (c === "\n" && !triple) return null;
else value += c;
}
return null;
}
function matcherRegExp(value: string, matcher: Matcher): RegExp | null {
if (matcher === "string") return new RegExp(`^${escapeRe(value)}$`);
if (matcher === "parse") return parseFormatRegExp(value);
try {
// Python's named groups and back-references; steps match the whole text.
const source = value.replace(/\(\?P<(\w+)>/g, "(?<$1>").replace(/\(\?P=(\w+)\)/g, "\\k<$1>");
return new RegExp(`^(?:${source})$`);
} catch {
return null;
}
}
const escapeRe = (s: string) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
const NUMBER = "[-+]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][-+]?\\d+)?";
/** The `parse` library's field types (`{count:d}`); others, and untyped fields, match any text. */
const PARSE_TYPES: Record<string, string> = {
d: "[-+]?\\d+",
n: "[-+]?\\d[\\d,]*",
f: NUMBER,
F: NUMBER,
e: NUMBER,
g: NUMBER,
w: "\\w+",
W: "\\W+",
s: "\\s+",
S: "\\S+",
D: "\\D+",
l: "[A-Za-z]+",
};
/**
* A `parse` format (`there are {count:d} cucumbers`) as an anchored, case-insensitive regular
* expression, as `parse` matches. `{{` and `}}` are literal braces; cfparse's cardinality
* (`{names:w+}`) matches any text. Null when a field is not closed.
*/
export function parseFormatRegExp(format: string): RegExp | null {
let out = "";
for (let i = 0; i < format.length; i++) {
const c = format[i]!;
if ((c === "{" || c === "}") && format[i + 1] === c) {
out += `\\${c}`;
i++;
} else if (c === "{") {
const end = format.indexOf("}", i);
if (end < 0) return null;
const field = format.slice(i + 1, end);
const spec = field.includes(":") ? field.slice(field.indexOf(":") + 1) : "";
out += `(${PARSE_TYPES[spec.slice(-1)] && !/[?*+]$/.test(spec) ? PARSE_TYPES[spec.slice(-1)] : ".+?"})`;
i = end;
} else out += escapeRe(c);
}
try {
return new RegExp(`^${out}$`, "i");
} catch {
return null;
}
}
/**
* The pending definition behave or pytest-bdd suggests for an undefined step, at the top level
* of the module. `body` is the line (0-based) the caret goes to.
*/
export function pythonStepSnippet(
keyword: string,
text: string,
framework: PythonFramework,
): { text: string; body: number } {
const decorator = keyword.toLowerCase();
const quoted = (s: string) => `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
if (framework === "pytest-bdd")
return {
text: [`@${decorator}(${quoted(text)})`, "def _():", " raise NotImplementedError", ""].join("\n"),
body: 2,
};
// behave reads the pattern as a `parse` format: braces in the step are literal.
const format = text.replace(/[{}]/g, "$&$&");
return {
text: [
`@${decorator}(${quoted(format)})`,
"def step_impl(context):",
` raise NotImplementedError(${quoted(`STEP: ${keyword} ${text}`)})`,
"",
].join("\n"),
body: 2,
};
}
/** The `from behave import …` (or `pytest_bdd`) line's insertion that adds `keyword`, if one is missing. */
export function pythonImportInsertion(
fileText: string,
keyword: string,
framework: PythonFramework,
): { at: number; text: string } | null {
const module = framework === "pytest-bdd" ? "pytest_bdd" : "behave";
const line = new RegExp(`^from[ \\t]+${module}[ \\t]+import[ \\t]+([\\w ,\\t]+?)[ \\t]*$`, "m").exec(fileText);
if (!line) return null;
const names = line[1]!.split(",").map((n) => n.trim());
const name = keyword.toLowerCase();
if (names.includes(name) || names.includes("*")) return null;
return { at: line.index + line[0].length, text: `, ${name}` };
}
+6 -4
Переглянути файл
@@ -35,7 +35,7 @@ export async function dialectOf(text: string): Promise<GherkinDialect> {
/** Whether a change to `path` can change the index: a feature or script file. */
export function isCucumberSource(path: string): boolean {
return /\.(feature|[cm]?[jt]sx?|java|kt)$/i.test(path);
return /\.(feature|[cm]?[jt]sx?|java|kt|py)$/i.test(path);
}
/** Forgets the index, so the next lookup rescans the project. */
@@ -51,7 +51,7 @@ function stepIndex(): Promise<StepIndex> {
const path = ipcPath(s.path);
if (s.feature) index.steps.push({ path, text: s.text, items: featureSteps(s.text, await dialectOf(s.text)) });
else {
const items = stepDefinitions(s.text);
const items = stepDefinitions(s.text, path);
if (items.length) index.definitions.push({ path, text: s.text, items });
}
}
@@ -110,13 +110,15 @@ export async function undefinedSteps(steps: readonly FeatureStep[]): Promise<Fea
/** The file a new definition for a step of `featurePath` goes to: the step file named like the feature, else the one with the most definitions. */
export async function definitionFileFor(featurePath: string): Promise<string | null> {
const { definitions } = await stepIndex();
// `cart.steps.ts`, `CartSteps.java` and `cart_stepdefs.kt` all name the `cart` feature's steps.
// `cart.steps.ts`, `CartSteps.java`, `cart_stepdefs.kt` and pytest-bdd's `test_cart.py` all
// name the `cart` feature's steps.
const stem = (path: string) =>
(path.split("/").pop() ?? "")
.split(".")[0]!
.toLowerCase()
.replace(/[^a-z0-9]/g, "")
.replace(/(?:stepdefinitions|stepdefs|steps)$/, "");
.replace(/(?:stepdefinitions|stepdefs|steps)$/, "")
.replace(/^test(?=.)/, "");
const feature = stem(featurePath);
const named = definitions.find((file) => stem(file.path) === feature);
if (named) return named.path;
+22 -5
Переглянути файл
@@ -2,8 +2,15 @@
* Cucumber steps, both sides: the step definitions of JavaScript / TypeScript files
* (`Given('a {int} item cart', …)` of `@cucumber/cucumber`, `playwright-bdd`'s `createBdd()`
* functions) and the steps of Gherkin `.feature` files, with Cucumber expression and regular
* expression matching between them.
* expression matching between them. Python files are read by `pythonSteps`.
*/
import {
pythonFramework,
pythonImportInsertion,
pythonStepDefinitions,
pythonStepSnippet,
type PythonFramework,
} from "./pythonSteps";
/**
* A step definition: the pattern literal of a `Given` / `When` / `Then` / `Step` call, or of a
@@ -35,8 +42,9 @@ export interface FeatureStep {
const DEFINE = /\b(?:Given|When|Then|And|But|Step|defineStep)\s*(?:<[^<>()]*>\s*)?\(\s*/g;
/** The step definitions of a script. */
export function stepDefinitions(text: string): StepDefinition[] {
/** The step definitions of a script; `path` tells a Python file from the others. */
export function stepDefinitions(text: string, path = ""): StepDefinition[] {
if (/\.py$/i.test(path)) return pythonStepDefinitions(text);
const out: StepDefinition[] = [];
for (const m of text.matchAll(DEFINE)) {
const at = m.index + m[0].length;
@@ -303,12 +311,15 @@ export function definingKeyword(steps: readonly FeatureStep[], step: FeatureStep
/** Strings and numbers of a step's text, as Cucumber's snippets turn them into parameters. */
const SNIPPET_PARAMETER = /(^|[^\w.-])("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|-?\d+\.\d+|-?\d+)(?![\w.])/g;
export type SnippetStyle = "cucumber" | "playwright-bdd" | "java" | "kotlin";
export type SnippetStyle = "cucumber" | "playwright-bdd" | "java" | "kotlin" | PythonFramework;
const isPython = (style: SnippetStyle): style is PythonFramework => style === "behave" || style === "pytest-bdd";
/** The snippet style of a step definition file. */
export function snippetStyle(path: string, text: string): SnippetStyle {
if (/\.java$/i.test(path)) return "java";
if (/\.kts?$/i.test(path)) return "kotlin";
if (/\.py$/i.test(path)) return pythonFramework(text);
return /\bcreateBdd\s*\(/.test(text) ? "playwright-bdd" : "cucumber";
}
@@ -351,6 +362,7 @@ export function stepSnippet(
text: string,
style: SnippetStyle = "cucumber",
): { text: string; body: number } {
if (isPython(style)) return pythonStepSnippet(keyword, text, style);
const jvm = style === "java" || style === "kotlin";
const types: string[] = [];
let expression = "";
@@ -457,7 +469,12 @@ export function definitionInsertions(
}
} else {
at = fileText.length;
const lead = !fileText ? "" : fileText.endsWith("\n\n") ? "" : fileText.endsWith("\n") ? "\n" : "\n\n";
const imported = isPython(style) ? pythonImportInsertion(fileText, keyword, style) : null;
if (imported) insertions.push(imported);
// Python separates top-level functions with two blank lines.
const gap = isPython(style) ? "\n\n\n" : "\n\n";
const ending = /\n*$/.exec(fileText)![0].length;
const lead = !fileText ? "" : gap.slice(Math.min(ending, gap.length));
insert = lead + snippet.text;
}
insertions.push({ at, text: insert });
+59 -1
Переглянути файл
@@ -26,7 +26,15 @@ vi.mock("@/workbench/contributions", async (orig) => ({
...(await orig<typeof import("@/workbench/contributions")>()),
maybeEditorService: () => ({ openFile: vi.fn(async () => {}) }),
}));
import { adoptSession, handleDebugEvent, selectThread, resumeExecution, useDebug, useExecutionPoint } from "../state";
import {
adoptSession,
handleDebugEvent,
isThreadSuspended,
selectThread,
resumeExecution,
useDebug,
useExecutionPoint,
} from "../state";
const path = "/proj/MsMemberUtils.java";
const frame = (line: number, id = 100): StackFrame => ({
@@ -126,6 +134,56 @@ describe("execution point state", () => {
expect(useExecutionPoint.getState().path).toBeNull();
});
it("moves to another thread still stopped by its own breakpoint when the current one continues", async () => {
stopped(5);
await settle();
ipc.debugStackTrace.mockResolvedValueOnce(ipc.ok([frame(9, 200)]));
stopped(1);
await settle();
ipc.debugStackTrace.mockResolvedValueOnce(ipc.ok([frame(6841)]));
await resumeExecution(1, async () => {
handleDebugEvent(1, { kind: "continued", threadId: 1, allThreadsContinued: false });
});
await settle();
expect(useDebug.getState().sessions[1]).toMatchObject({
status: "paused",
stoppedThread: 5,
selectedThread: 5,
stopReason: "step",
selectedFrame: 100,
});
expect(useExecutionPoint.getState()).toMatchObject({ path, line: 6841 });
expect(isThreadSuspended(useDebug.getState().sessions[1]!, 5)).toBe(true);
expect(isThreadSuspended(useDebug.getState().sessions[1]!, 1)).toBe(false);
handleDebugEvent(1, { kind: "continued", threadId: 5, allThreadsContinued: false });
expect(useDebug.getState().sessions[1]?.status).toBe("running");
});
it("forgets a stopped thread that continues while another one is shown", async () => {
stopped(5);
await settle();
stopped(1);
await settle();
handleDebugEvent(1, { kind: "continued", threadId: 5, allThreadsContinued: false });
expect(useDebug.getState().sessions[1]).toMatchObject({ status: "paused", stoppedThread: 1 });
handleDebugEvent(1, { kind: "continued", threadId: 1, allThreadsContinued: false });
expect(useDebug.getState().sessions[1]?.status).toBe("running");
});
it.each([
["every thread continues", false, true],
["the stop suspended every thread", true, false],
])("runs when %s", async (_, allStopped, allContinued) => {
stopped(5, allStopped);
await settle();
stopped(1, allStopped);
await settle();
expect(isThreadSuspended(useDebug.getState().sessions[1]!, 5)).toBe(true);
handleDebugEvent(1, { kind: "continued", threadId: 1, allThreadsContinued: allContinued });
expect(useDebug.getState().sessions[1]?.status).toBe("running");
expect(isThreadSuspended(useDebug.getState().sessions[1]!, 5)).toBe(false);
});
it.each(["continued", "terminated"] as const)("clears the execution point on %s", async (kind) => {
stopped();
await settle();
+75
Переглянути файл
@@ -0,0 +1,75 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
const ipc = vi.hoisted(() => ({
debugResolveVariable: vi.fn(),
debugVariables: vi.fn(),
}));
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
return { ...real, isTauri: () => true, commands: { ...real.commands, ...ipc } };
});
import type { DebugSessionId, Variable } from "@/platform/ipc";
import { VariablesView, type VarRoot } from "../ui/VariablesView";
const ok = <T,>(data: T) => Promise.resolve({ status: "ok" as const, data });
// java-debug's shape: the row's reference (201) holds one nameless variable with the value
// and the reference of the fields (202).
const ORDER: Variable = {
name: "order",
value: "Order@7",
typeName: "Order",
variablesReference: 201,
evaluateName: "order",
lazy: true,
};
const COMPUTED: Variable = { ...ORDER, value: 'Order@7 "Order(1)"', variablesReference: 202, lazy: false };
const FIELDS: Variable[] = [
{ name: "id", value: "1", typeName: "int", variablesReference: 0, evaluateName: "order.id" },
];
const roots: VarRoot[] = [{ key: "order", kind: "var", variable: ORDER, container: 100 }];
function setup() {
ipc.debugResolveVariable.mockImplementation(() => ok(COMPUTED));
ipc.debugVariables.mockImplementation((_s: DebugSessionId, ref: number) => ok(ref === 202 ? FIELDS : []));
render(<VariablesView roots={roots} session={1 as DebugSessionId} aria-label="Variables" />);
return screen.getByRole("tree");
}
const rows = (tree: HTMLElement) =>
within(tree)
.queryAllByRole("treeitem")
.map((el) => el.textContent);
afterEach(() => {
cleanup();
vi.clearAllMocks();
});
describe("lazy variables", () => {
it("opening a lazy row computes its value in place and lists its fields, not a nameless value", async () => {
const tree = setup();
tree.focus();
fireEvent.keyDown(tree, { key: "Home" });
fireEvent.keyDown(tree, { key: "ArrowRight" });
await waitFor(() => expect(rows(tree)).toHaveLength(2));
expect(rows(tree)[0]).toContain('"Order(1)"');
expect(rows(tree)[1]).toMatch(/^id=/);
expect(ipc.debugResolveVariable).toHaveBeenCalledWith(1, expect.objectContaining({ variablesReference: 201 }));
expect(ipc.debugVariables).toHaveBeenCalledTimes(1);
expect(ipc.debugVariables).toHaveBeenCalledWith(1, 202);
});
it("clicking the lazy marker computes the value without opening the row", async () => {
const tree = setup();
fireEvent.click(screen.getByRole("button", { name: "Compute the value" }));
await waitFor(() => expect(rows(tree)[0]).toContain('"Order(1)"'));
expect(screen.queryByRole("button", { name: "Compute the value" })).toBeNull();
expect(rows(tree)).toHaveLength(1);
expect(ipc.debugVariables).not.toHaveBeenCalled();
});
});
+5
Переглянути файл
@@ -22,6 +22,11 @@ describe("valueText", () => {
);
});
it("does not open a lazy child, whose reference holds only its uncomputed value", async () => {
const tree = { 1: [{ ...v("total", "(...)", 2), lazy: true }], 2: [v("", "3")] };
expect(await valueText({ value: "Cart", reference: 1 }, fetcher(tree))).toBe("Cart\n total: (...)");
});
it("stops at a cycle", async () => {
const tree = { 1: [v("self", "Node", 1)] };
expect(await valueText({ value: "Node", reference: 1 }, fetcher(tree))).toBe("Node\n self: Node");
+53 -3
Переглянути файл
@@ -84,6 +84,13 @@ export interface DebugSession {
stoppedThread: number | null;
stopReason: string | null;
stopDescription: string | null;
/**
* Threads stopped alone (a `stopped` event without `allThreadsStopped`), oldest first. Adapters
* such as java-debug keep them suspended while another thread runs.
*/
suspendedThreads?: SuspendedThread[];
/** The last stop suspended every thread. */
allThreadsStopped?: boolean;
threads: ThreadInfo[];
selectedThread: number | null;
frames: StackFrame[];
@@ -107,6 +114,12 @@ export interface DebugSession {
flutterAppStarted?: boolean;
}
export interface SuspendedThread {
id: number;
reason: string;
description: string | null;
}
export interface ConsoleLine {
id: number;
category: string;
@@ -1051,6 +1064,11 @@ export function pausedThread(s: DebugSession): number | null {
return s.selectedThread ?? s.stoppedThread ?? s.threads[0]?.id ?? null;
}
export function isThreadSuspended(s: DebugSession, threadId: number): boolean {
if (s.status !== "paused") return false;
return !!s.allThreadsStopped || s.stoppedThread === threadId || !!s.suspendedThreads?.some((t) => t.id === threadId);
}
/** The selected frame of the paused session (top frame when none is selected). */
export function selectedFrame(s: DebugSession): StackFrame | null {
return s.frames.find((f) => f.id === s.selectedFrame) ?? s.frames[0] ?? null;
@@ -1116,7 +1134,8 @@ export function selectFrame(id: DebugSessionId, frameId: number, reveal = true)
void loadLocals(id, frameId);
}
async function loadFrames(id: DebugSessionId, threadId: number, reveal: boolean) {
/** `newStop`: false when returning to an earlier stop, whose breakpoint hit was handled when it happened. */
async function loadFrames(id: DebugSessionId, threadId: number, reveal: boolean, newStop = true) {
const before = useDebug.getState().sessions[id];
let frames: StackFrame[] = [];
try {
@@ -1128,7 +1147,7 @@ async function loadFrames(id: DebugSessionId, threadId: number, reveal: boolean)
if (!s || s.status !== "paused" || s.selectedThread !== threadId || s.frames !== before?.frames) return;
patch(id, { frames });
const top = topFrame(frames);
if (top?.path && (s.stopReason === "breakpoint" || s.stopReason === "function breakpoint")) {
if (newStop && top?.path && (s.stopReason === "breakpoint" || s.stopReason === "function breakpoint")) {
void logSuspendingHit(id, top);
consumeTemporary(top.path, top.line);
}
@@ -1377,8 +1396,13 @@ export function handleDebugEvent(id: DebugSessionId, event: DebugEvent) {
break;
case "stopped": {
const isBp = event.reason === "breakpoint" || event.reason === "function breakpoint";
const alone = (s.suspendedThreads ?? []).filter((t) => t.id !== event.threadId);
if (!event.allThreadsStopped)
alone.push({ id: event.threadId, reason: event.reason, description: event.description });
patch(id, {
status: "paused",
suspendedThreads: event.allThreadsStopped ? [] : alone,
allThreadsStopped: event.allThreadsStopped,
stoppedThread: event.threadId,
selectedThread: event.threadId,
stopReason: event.reason,
@@ -1410,13 +1434,39 @@ export function handleDebugEvent(id: DebugSessionId, event: DebugEvent) {
case "continued": {
const cur = useDebug.getState().sessions[id]!;
if (cur.status === "terminated") break;
if (!event.allThreadsContinued && event.threadId !== (cur.selectedThread ?? cur.stoppedThread)) break;
const rest = event.allThreadsContinued ? [] : (cur.suspendedThreads ?? []).filter((t) => t.id !== event.threadId);
if (!event.allThreadsContinued && event.threadId !== (cur.selectedThread ?? cur.stoppedThread)) {
patch(id, { suspendedThreads: rest });
break;
}
stopTaskbarFlash();
const next = rest.at(-1);
if (next) {
// Like IDEA, the session stays suspended on a thread its own breakpoint still holds.
patch(id, {
status: "paused",
suspendedThreads: rest,
stoppedThread: next.id,
selectedThread: next.id,
stopReason: next.reason,
stopDescription: next.description,
frames: [],
selectedFrame: null,
});
useDebug.setState((st) => ({ stopSeq: st.stopSeq + 1 }));
publishContext();
updateExecutionPoint();
void loadThreads(id);
void loadFrames(id, next.id, true, false);
break;
}
patch(id, {
status: "running",
frames: [],
selectedFrame: null,
stoppedThread: null,
suspendedThreads: [],
allThreadsStopped: false,
});
updateExecutionPoint();
break;
+2 -1
Переглянути файл
@@ -32,6 +32,7 @@ import {
closeSessionTab,
evaluate,
isLive,
isThreadSuspended,
selectFrame,
selectSession,
selectThread,
@@ -406,7 +407,7 @@ function FramesPane({ session }: { session: DebugSession }) {
value: String(t.id),
label: t.name,
verbatim: true,
detail: t.id === session.stoppedThread ? "suspended" : undefined,
detail: isThreadSuspended(session, t.id) ? "suspended" : undefined,
}))}
onChange={(v) => void selectThread(session.id, +v)}
aria-label="Thread"
+117 -23
Переглянути файл
@@ -44,6 +44,8 @@ interface VarNode {
depth0: boolean;
/** variablesReference of the parent (0 when unknown). */
container: number;
/** `value` is not computed yet; `reference` holds it as a single nameless variable. */
lazy: boolean;
}
function fromRoot(r: VarRoot): VarNode {
@@ -60,6 +62,7 @@ function fromRoot(r: VarRoot): VarNode {
error: null,
depth0: true,
container: 0,
lazy: false,
};
case "var":
return fromVariable(r.key, r.variable, r.container ?? 0, true);
@@ -75,6 +78,7 @@ function fromRoot(r: VarRoot): VarNode {
error: r.error,
depth0: true,
container: 0,
lazy: !!r.variable?.lazy,
};
}
}
@@ -91,6 +95,18 @@ function fromVariable(key: string, v: Variable, container: number, depth0 = fals
error: null,
depth0,
container,
lazy: !!v.lazy,
};
}
function toVariable(n: VarNode): Variable {
return {
name: n.name,
value: n.value,
typeName: n.typeName,
variablesReference: n.reference,
evaluateName: n.evaluateName,
lazy: n.lazy,
};
}
@@ -106,6 +122,7 @@ function message(key: string, text: string): VarNode {
error: null,
depth0: false,
container: 0,
lazy: false,
};
}
@@ -140,6 +157,37 @@ export class ValueChanges {
}
}
/** Per stop (`gen`): loaded children by parent key, and lazy rows whose value was computed. */
interface ViewCache {
gen: number;
map: Map<string, VarNode[]>;
resolved: Map<string, VarNode>;
}
const emptyCache = (gen: number): ViewCache => ({ gen, map: new Map(), resolved: new Map() });
/** `c` for stop `gen` with `next` in place of the row of the same key. */
function withResolved(c: ViewCache, gen: number, next: VarNode): ViewCache {
const base = c.gen === gen ? c : emptyCache(gen);
const map = new Map(base.map);
for (const [parent, list] of map)
if (list.some((n) => n.key === next.key))
map.set(
parent,
list.map((n) => (n.key === next.key ? next : n)),
);
return { gen, map, resolved: new Map(base.resolved).set(next.key, next) };
}
/** A lazy row with its value computed; a failure shows on the row. */
function computeLazy(session: DebugSessionId, node: VarNode): Promise<VarNode> {
return call(commands.debugResolveVariable(session, toVariable(node))).then(
// Still lazy: the adapter gave no single value, so the row opens as an ordinary one.
(v) => ({ ...fromVariable(node.key, v, node.container, node.depth0), kind: node.kind, lazy: false }),
(e) => ({ ...node, lazy: false, reference: 0, error: e instanceof Error ? e.message : String(e) }),
);
}
const tracksChanges = (n: VarNode) => (n.kind === "var" || n.kind === "watch") && !n.error;
/** Shared by every view: the variables pane remounts while the program runs between stops. */
@@ -170,13 +218,22 @@ export function VariablesView({
className,
...aria
}: VariablesViewProps) {
const [cache, setCache] = useState<{ gen: number; map: Map<string, VarNode[]> }>({ gen: generation, map: new Map() });
const children = cache.gen === generation ? cache.map : null;
const [cache, setCache] = useState<ViewCache>(() => emptyCache(generation));
const current = cache.gen === generation ? cache : null;
const children = current?.map ?? null;
const resolved = current?.resolved ?? null;
const [expanded, setExpanded] = useState<Set<string>>(() => new Set(defaultExpanded));
const loading = useRef(new Set<string>());
const tree = useRef<TreeHandle>(null);
const nodes = useMemo(() => roots.map(fromRoot), [roots]);
const nodes = useMemo(
() =>
roots.map((r) => {
const n = fromRoot(r);
return resolved?.get(n.key) ?? n;
}),
[roots, resolved],
);
const byKey = useMemo(() => {
const m = new Map<string, VarNode>();
const walk = (list: readonly VarNode[]) =>
@@ -202,32 +259,52 @@ export function VariablesView({
if (autoFocus) tree.current?.focus();
}, [autoFocus]);
const resolve = useCallback(
async (node: VarNode): Promise<VarNode> => {
if (session == null || !node.lazy) return node;
const next = await computeLazy(session, node);
setCache((c) => withResolved(c, generation, next));
return next;
},
[session, generation],
);
const load = useCallback(
async (node: VarNode) => {
if (session == null || node.reference <= 0) return;
const tag = `${generation}:${node.key}`;
async (opened: VarNode) => {
if (session == null || opened.reference <= 0) return;
const { key } = opened;
const tag = `${generation}:${key}`;
if (loading.current.has(tag)) return;
loading.current.add(tag);
let list: VarNode[];
let list: VarNode[] = [];
let computed: VarNode | null = null;
try {
const raw = await call(commands.debugVariables(session, node.reference));
const vars = workflowSettings().debugger.sortValues ? sortVariables(raw) : raw;
const seen = new Map<string, number>();
list = vars.map((v) => {
const n = (seen.get(v.name) ?? 0) + 1;
seen.set(v.name, n);
return fromVariable(`${node.key}/${v.name}${n > 1 ? `#${n}` : ""}`, v, node.reference);
});
if (!list.length) list = [message(`${node.key}/\u0000empty`, "No variables")];
// Opening a lazy row computes its value first: its own reference holds only that value.
if (opened.lazy) computed = await computeLazy(session, opened);
const node = computed ?? opened;
if (node.reference > 0) {
const raw = await call(commands.debugVariables(session, node.reference));
const vars = workflowSettings().debugger.sortValues ? sortVariables(raw) : raw;
const seen = new Map<string, number>();
list = vars.map((v) => {
const n = (seen.get(v.name) ?? 0) + 1;
seen.set(v.name, n);
return fromVariable(`${key}/${v.name}${n > 1 ? `#${n}` : ""}`, v, node.reference);
});
if (!list.length) list = [message(`${key}/\u0000empty`, "No variables")];
}
} catch (e) {
list = [message(`${node.key}/\u0000error`, e instanceof Error ? e.message : String(e))];
list = [message(`${key}/\u0000error`, e instanceof Error ? e.message : String(e))];
} finally {
loading.current.delete(tag);
}
setCache((c) => {
const map = new Map(c.gen === generation ? c.map : []);
map.set(node.key, list);
return { gen: generation, map };
const base = computed
? withResolved(c, generation, computed)
: c.gen === generation
? c
: emptyCache(generation);
return { ...base, map: new Map(base.map).set(key, list) };
});
},
[session, generation],
@@ -282,7 +359,8 @@ export function VariablesView({
const canWatch = (n: VarNode) =>
session != null && n.kind === "var" && n.container > 0 && sessionSupports("dataBreakpoints");
const copyValue = async (node: VarNode) => {
const copyValue = async (row: VarNode) => {
const node = await resolve(row);
let text = node.value;
const paused = session != null ? useDebug.getState().sessions[session] : undefined;
if (paused?.status === "paused" && node.reference <= 0 && node.evaluateName) {
@@ -388,7 +466,7 @@ export function VariablesView({
}}
/>
) : (
<VarRow node={n} changed={isChanged(n)} onShowValue={setValuePopup} />
<VarRow node={n} changed={isChanged(n)} onShowValue={setValuePopup} onResolve={(n) => void resolve(n)} />
)
}
/>
@@ -509,10 +587,12 @@ function VarRow({
node,
changed,
onShowValue,
onResolve,
}: {
node: VarNode;
changed: boolean;
onShowValue: (node: VarNode) => void;
onResolve: (node: VarNode) => void;
}) {
const valueRef = useRef<HTMLSpanElement>(null);
const [overflow, setOverflow] = useState(false);
@@ -575,7 +655,21 @@ function VarRow({
<span ref={valueRef} className={clsx(styles.value, kind && styles[kind])} title={node.value}>
{oneLine(shown.text)}
</span>
{overflow && (
{node.lazy && (
<button
type="button"
className={styles.showValue}
title={tx("Compute the value")}
aria-label={tx("Compute the value")}
onClick={(e) => {
e.stopPropagation();
onResolve(node);
}}
>
(…)
</button>
)}
{!node.lazy && overflow && (
<button
type="button"
className={styles.showValue}
+2 -1
Переглянути файл
@@ -40,7 +40,8 @@ export async function valueText(
}
lines.push(`${pad}${child.name}: ${child.value}`);
const ref = child.variablesReference;
if (ref > 0 && !path.has(ref)) {
// A lazy child's reference holds its uncomputed value, not its contents.
if (ref > 0 && !child.lazy && !path.has(ref)) {
path.add(ref);
await walk(ref, depth + 1);
path.delete(ref);
+3 -4
Переглянути файл
@@ -6,12 +6,11 @@ import { defaultKeymap, history, historyKeymap, indentWithTab, redo, undo } from
import { syntaxHighlighting } from "@codemirror/language";
import { caretRowHighlight } from "@/editor/core/cm/caretRow";
import { findExtension, findResultLines, findScope, type FindOptions } from "@/editor/core/cm/find";
import { foldingExtension } from "@/editor/core/cm/folding";
import { openideaHighlightStyle } from "@/editor/core/cm/highlight";
import { overviewLane } from "@/editor/core/cm/lanes";
import { findLanguageDescription, loadSupport } from "@/editor/core/cm/languages";
import { caretExtension, fontZoom, setFontZoom, stepFontZoom } from "@/editor/core/cm/prefs";
import { fontExtension, heavyExtension, lineNumbersExtension } from "@/editor/core/cm/setup";
import { foldingFor, fontExtension, heavyExtension, lineNumbersExtension } from "@/editor/core/cm/setup";
import { openideaTheme } from "@/editor/core/cm/theme";
import { FindPanel, searchAgain, seedFind, type FindTarget } from "@/editor/core/view/FindBar";
import { executeAction } from "@/platform/actions";
@@ -417,7 +416,7 @@ function PluginContentEditorBody({ input, initialData }: { input: EditorInput; i
fontSlot.of(fontExtension(editorSettings())),
caretSlot.of(caretExtension(editorPrefs())),
lineNumbersSlot.of(lineNumbersExtension(editorSettings())),
foldingSlot.of(foldingExtension(editorPrefs().folding.showOutline)),
foldingSlot.of(foldingFor(editorSettings())),
heavySlot.of(heavyExtension(session.currentText.length, editorSettings())),
langSlot.of([]),
readOnlySlot.of([EditorState.readOnly.of(effectiveReadOnly), EditorView.editable.of(!effectiveReadOnly)]),
@@ -482,7 +481,7 @@ function PluginContentEditorBody({ input, initialData }: { input: EditorInput; i
effects.push(
fontSlot.reconfigure(fontExtension(nextEditor)),
lineNumbersSlot.reconfigure(lineNumbersExtension(nextEditor)),
foldingSlot.reconfigure(foldingExtension(nextPrefs.folding.showOutline)),
foldingSlot.reconfigure(foldingFor(nextEditor)),
heavySlot.reconfigure(heavyExtension(view.state.doc.length, nextEditor)),
);
}
+3 -2
Переглянути файл
@@ -8,6 +8,7 @@ import { CLASSPATH, TEST_CLASSPATH, jvmModuleDir } from "@/platform/javaLaunch";
import { isTestPath, rootFor } from "@/platform/languageSettings";
import { currentRoots } from "@/platform/projectRoots";
import { simpleClassName } from "./jvmTargets";
import { withMavenTests } from "./mavenTests";
export { jvmModuleDir } from "@/platform/javaLaunch";
@@ -49,7 +50,7 @@ export function applicationConfig(
/**
* Narrows a Maven / Gradle test configuration to a class (`method` unset) or
* one method: Surefire `-Dtest=Class#method`, Gradle `--tests Class.method`.
* `fileConfig` is the file-level configuration whose last argument is the file filter.
* `fileConfig` is the file-level configuration; for Gradle its last argument is the file filter.
*/
export function jvmTestConfig(fileConfig: RunConfig, className: string, method: string | undefined): RunConfig | null {
const args = fileConfig.args.slice(0, -1);
@@ -63,7 +64,7 @@ export function jvmTestConfig(fileConfig: RunConfig, className: string, method:
id,
name,
env: { ...fileConfig.env },
args: [...args, `-Dtest=${className}${method ? `#${method}` : ""}`, "-Dsurefire.failIfNoSpecifiedTests=false"],
args: withMavenTests(fileConfig.args, `${className}${method ? `#${method}` : ""}`),
};
case "gradle":
return {
+9 -3
Переглянути файл
@@ -4,12 +4,15 @@
* direct interpreter invocation for main files. Best effort, IDEA-style.
*/
import type { RunConfig } from "@/platform/ipc";
import { jvmModuleDir } from "@/platform/javaLaunch";
import { djangoLabel, djangoTestsOf, hasDjangoTests } from "./djangoTypes";
import { inGradleModule } from "./gradleModuleTests";
import { systemPython } from "./pythonTypes";
import { phpunitArgs } from "./testing/phpunit";
import { goTestParts } from "./goArguments";
import { goBuildType } from "./goTypes";
import { isWindows } from "./jvmTypes";
import { withMavenTests } from "./mavenTests";
import { typeFor } from "./types";
import { runTemplate } from "./runTemplates";
import { appendScriptArgs } from "./scriptArgs";
@@ -276,10 +279,13 @@ export function testConfigFor(
const m = /(?:^|\/)tests\/([^/]+)\.rs$/.exec(relPath);
return m ? derived(base, relPath, { args: [...base.args, "--test", m[1]!] }) : base;
}
case "gradle":
return derived(base, relPath, { args: [...base.args, "--tests", `*${stem(relPath)}`] });
case "gradle": {
// Class and method runs narrow this file configuration, so they inherit its subproject task.
const module = inGradleModule(base, jvmModuleDir(relPath, configs));
return derived(module, relPath, { args: [...module.args, "--tests", `*${stem(relPath)}`] });
}
case "maven":
return derived(base, relPath, { args: [...base.args, `-Dtest=${stem(relPath)}`] });
return derived(base, relPath, { args: withMavenTests(base.args, stem(relPath)) });
}
return base;
}
+40
Переглянути файл
@@ -0,0 +1,40 @@
import type { RunConfig } from "@/platform/ipc";
import { useBuildModel } from "@/platform/buildModel";
/**
* The Gradle build and project path a module directory belongs to. `null` for non-Gradle
* bases and modules the base configuration already runs. Without a loaded model, the Gradle
* path is guessed from the directory's segments below the build: right for the standard
* layout the wrapper itself implies.
*/
function gradleOwnerFor(module: string, base: RunConfig): { dir: string | null; path: string } | null {
if (base.kind !== "gradle" || !module || module === base.cwd) return null;
const dir = module.replace(/\\/g, "/");
const gradle = useBuildModel
.getState()
.model?.gradle?.find((g) => g.projects.some((p) => p.dir.replace(/\\/g, "/") === dir));
const project = gradle?.projects.find((p) => p.dir.replace(/\\/g, "/") === dir);
const build = (base.cwd ?? "").replace(/\\/g, "/").replace(/\/+$/, "");
const inBuild = build && dir.startsWith(`${build}/`) ? dir.slice(build.length + 1) : dir;
return {
dir: gradle ? gradle.dir || null : base.cwd,
path: project?.path ?? `:${inBuild.split("/").join(":")}`,
};
}
/**
* `base`, a Gradle test configuration, narrowed to the subproject in `module`: it runs from the
* build root, where `./gradlew` resolves, with its `test` task qualified by the subproject's
* Gradle path (`services/api` → `:services:api:test`). `--tests` on the plain `test` task
* filters every subproject's tests, and one without a match fails the build ("No tests found
* for given includes") before the subproject holding the test runs.
*/
export function inGradleModule(base: RunConfig, module: string): RunConfig {
const owner = gradleOwnerFor(module, base);
if (!owner) return base;
return {
...base,
cwd: owner.dir,
args: base.args.map((a) => (a === "test" ? `${owner.path}:test` : a)),
};
}
+6 -1
Переглянути файл
@@ -261,7 +261,12 @@ describe("application configurations", () => {
});
it("scopes Maven and Gradle test configs to a class or method", () => {
const file = cfg({ id: "f", kind: "maven", args: ["test", "-Dtest=OrderTest"], isTest: true });
const file = cfg({
id: "f",
kind: "maven",
args: ["test", "-Dtest=OrderTest", "-Dsurefire.failIfNoSpecifiedTests=false"],
isTest: true,
});
expect(jvmTestConfig(file, "a.OrderTest$Nested", "fails")).toMatchObject({
name: "Nested.fails",
args: ["test", "-Dtest=a.OrderTest$Nested#fails", "-Dsurefire.failIfNoSpecifiedTests=false"],
+19
Переглянути файл
@@ -63,6 +63,25 @@ describe("JUnit configurations", () => {
expect(line({ testKind: "all", vmOptions: "-Xmx1g" }).args).toEqual([":api:test"]);
});
it("run a subproject's tests with its own task when the build's test configuration is the root's", () => {
const root = [cfg({ id: "gradle:test", kind: "gradle", args: ["test"], isTest: true })];
const line = (p: Record<string, string>) => junitCommandLine({ module: "services/api", ...p }, root);
expect(line({ testKind: "method", className: "a.OrderTest", methodName: "ships" })).toEqual({
command: "./gradlew",
args: [":services:api:test", "--tests", "a.OrderTest.ships"],
cwd: null,
});
expect(line({ testKind: "class", className: "a.OrderTest" }).args).toEqual([
":services:api:test",
"--tests",
"a.OrderTest",
]);
expect(line({ testKind: "package", packageName: "a.b" }).args).toEqual([":services:api:test", "--tests", "a.b.*"]);
expect(line({ testKind: "pattern", pattern: "*IT" }).args).toEqual([":services:api:test", "--tests", "*IT"]);
expect(line({ testKind: "all" }).args).toEqual([":services:api:test"]);
expect(junitCommandLine({ module: ".", testKind: "all" }, root).args).toEqual(["test"]);
});
it("run nothing without a Maven or Gradle build, and debug and report like build runs", () => {
expect(junitCommandLine({ testKind: "all" }, []).command).toBe("");
const line = junitCommandLine({ testKind: "class", className: "a.OrderTest" }, maven);
+9 -7
Переглянути файл
@@ -7,6 +7,7 @@ import type { RunConfig } from "@/platform/ipc";
import type { RunConfigTypeContribution } from "@/workbench/contributions";
import { jvmTestConfig } from "./application";
import { testBasesFor, testConfigFor } from "./context";
import { inGradleModule } from "./gradleModuleTests";
import {
ROOT_MODULE,
buildModuleOptions,
@@ -15,6 +16,7 @@ import {
splitJvmArgs,
vmOptionsField,
} from "./jvmTypes";
import { withMavenTests } from "./mavenTests";
import { useRun } from "./store";
type TestKind = "all" | "package" | "class" | "method" | "pattern";
@@ -37,11 +39,10 @@ export function junitCommandLine(
p: Readonly<Record<string, string>>,
configs: RunConfig[],
): { command: string; args: string[]; cwd: string | null } {
const base = baseFor(p, configs);
if (!base) return { command: "", args: [], cwd: null };
const detected = baseFor(p, configs);
if (!detected) return { command: "", args: [], cwd: null };
const base = inGradleModule(detected, moduleDir(p));
const maven = base.kind === "maven";
const select = (pattern: string): string[] =>
maven ? [`-Dtest=${pattern}`, "-Dsurefire.failIfNoSpecifiedTests=false"] : ["--tests", pattern];
let args = [...base.args];
const cls = p.className?.trim() ?? "";
switch (kindOf(p)) {
@@ -49,14 +50,14 @@ export function junitCommandLine(
case "method": {
if (!cls) break;
const method = kindOf(p) === "method" ? p.methodName?.trim() || undefined : undefined;
const file = testConfigFor(inModule(p, `src/test/java/${cls.replace(/\./g, "/")}.java`), configs, base);
const file = testConfigFor(inModule(p, `src/test/java/${cls.replace(/\./g, "/")}.java`), configs, detected);
const narrowed = file && jvmTestConfig(file, cls, method);
if (narrowed) args = narrowed.args;
break;
}
case "package": {
const pkg = p.packageName?.trim();
if (pkg) args.push(...select(maven ? `${pkg}.**.*` : `${pkg}.*`));
if (pkg) args = maven ? withMavenTests(args, `${pkg}.**.*`) : [...args, "--tests", `${pkg}.*`];
break;
}
case "pattern": {
@@ -64,7 +65,8 @@ export function junitCommandLine(
.split(",")
.map((s) => s.trim())
.filter(Boolean);
if (patterns.length) args.push(...(maven ? select(patterns.join(",")) : patterns.flatMap(select)));
if (patterns.length)
args = maven ? withMavenTests(args, patterns.join(",")) : [...args, ...patterns.flatMap((p) => ["--tests", p])];
break;
}
case "all":
+11
Переглянути файл
@@ -0,0 +1,11 @@
/**
* Surefire's test selection for a Maven run. In a reactor, `-Dtest` applies to every module, and a
* module without a matching test fails the build ("No tests matching pattern") before the module
* that has it runs, so every selection also lets modules without matches pass.
*/
const NO_MATCH_OK = "-Dsurefire.failIfNoSpecifiedTests=false";
/** `args` running only the tests `pattern` selects (Surefire syntax), replacing an earlier selection. */
export function withMavenTests(args: readonly string[], pattern: string): string[] {
return [...args.filter((a) => !a.startsWith("-Dtest=") && a !== NO_MATCH_OK), `-Dtest=${pattern}`, NO_MATCH_OK];
}
+45 -2
Переглянути файл
@@ -721,7 +721,7 @@ describe("single-file producers (scratches)", () => {
ALL,
)!;
expect(t.config).toMatchObject({ kind: "gradle", cwd: "backend" });
expect(t.config!.args).toEqual(["test", "--tests", "demo.AppTest.works"]);
expect(t.config!.args).toEqual([":app:test", "--tests", "demo.AppTest.works"]);
});
it("a test-named class with a main runs its main; without one, its tests (IDEA semantics)", () => {
@@ -750,7 +750,8 @@ describe("single-file producers (scratches)", () => {
ALL,
)!;
expect(tests.config).toMatchObject({ kind: "maven", isTest: true });
expect(tests.config!.args).toEqual(["test", "-Dtest=Test"]);
// A reactor module without `Test` must not fail the build before the module that has it.
expect(tests.config!.args).toEqual(["test", "-Dtest=Test", "-Dsurefire.failIfNoSpecifiedTests=false"]);
});
});
@@ -1004,6 +1005,48 @@ describe("project producers", () => {
expect(produceDirectory({ path: `${ROOT}/src/main`, root: ROOT, configs })).toBeNull();
expect(produceDirectory({ path: ROOT, root: ROOT, configs })).toBeNull();
});
// `--tests` on the root `test` runs every subproject's test task, and one without a match
// fails the build ("No tests found for given includes") before the subproject with the test.
it("Gradle: a subproject's test class, method and file run that subproject's test task", () => {
const gradle = [cfg({ id: "gradle:test", kind: "gradle", command: "./gradlew", args: ["test"], isTest: true })];
const content =
"package com.acme;\n\nimport org.junit.jupiter.api.Test;\n\nclass OrderTest {\n @Test\n void ships() {\n }\n}\n";
const input = (path: string, configs = gradle, line?: number): ContextInput => ({
path: `${ROOT}/${path}`,
root: ROOT,
configs,
content,
line,
});
const file = "services/api/src/test/java/com/acme/OrderTest.java";
const method = produceContext(input(file, gradle, 6), ALL)!.config!;
expect(method).toMatchObject({ cwd: null, args: [":services:api:test", "--tests", "com.acme.OrderTest.ships"] });
expect(produceContext(input(file, gradle, 4), ALL)!.config!.args).toEqual([
":services:api:test",
"--tests",
"com.acme.OrderTest",
]);
expect(produceFile(input(file), ALL)!.config).toMatchObject({
cwd: null,
args: [":services:api:test", "--tests", "*OrderTest"],
});
// The root project's own tests keep the plain task.
expect(produceFile(input("src/test/java/com/acme/OrderTest.java"), ALL)!.config!.args).toEqual([
"test",
"--tests",
"*OrderTest",
]);
// A build nested in a folder: the subproject path is relative to that build.
const nested = [cfg({ id: "gradle:test:shop", kind: "gradle", args: ["test"], cwd: "shop", isTest: true })];
expect(produceFile(input("shop/api/src/test/java/com/acme/OrderTest.java", nested), ALL)!.config).toMatchObject({
cwd: "shop",
args: [":api:test", "--tests", "*OrderTest"],
});
expect(
produceDirectory({ path: `${ROOT}/shop/api/src/test/java`, root: ROOT, configs: nested })!.config!.args,
).toEqual([":api:test"]);
});
});
describe("file-level gutter targets", () => {
+7 -39
Переглянути файл
@@ -14,7 +14,7 @@ import { ipcPath, isSameOrInside } from "@/platform/paths";
import { isTestPath } from "@/platform/languageSettings";
import { currentRoots } from "@/platform/projectRoots";
import { applicationConfig, jvmModuleDir } from "./application";
import { useBuildModel } from "@/platform/buildModel";
import { inGradleModule } from "./gradleModuleTests";
import { formatArgs } from "./configs";
import { goGenerateConfig } from "./goGenerate";
import { goTestParts } from "./goArguments";
@@ -31,6 +31,7 @@ import { djangoLabel, djangoTestsOf, hasDjangoTests } from "./djangoTypes";
import { firstTopLevelType, scanJvmTargets, simpleClassName } from "./jvmTargets";
import { isWindows } from "./jvmTypes";
import { inheritedRunTargets } from "./inheritedMain";
import { withMavenTests } from "./mavenTests";
import { detectRunTargets, goFuzzConfig, targetConfig, targetLanguage, zigTargets, type RunTarget } from "./targets";
import { tx } from "@/platform/i18n";
@@ -1278,27 +1279,6 @@ function rubyDirectory(
return make(minitest, label, [...args, relToCwd(minitest)]);
}
/**
* The Gradle build and project path a module directory belongs to, so a module
* test run can stay in the build root (where `./gradlew` resolves) and qualify
* its task (`:services:api:test`). `null` for non-Gradle bases and modules the
* base configuration already runs. Without a loaded model, the Gradle path is
* guessed from the directory's segments — right for the standard layout the
* wrapper itself implies.
*/
function gradleOwnerFor(module: string, base: RunConfig): { dir: string | null; path: string } | null {
if (base.kind !== "gradle" || !module || module === base.cwd) return null;
const dir = module.replace(/\\/g, "/");
const gradle = useBuildModel
.getState()
.model?.gradle?.find((g) => g.projects.some((p) => p.dir.replace(/\\/g, "/") === dir));
const project = gradle?.projects.find((p) => p.dir.replace(/\\/g, "/") === dir);
return {
dir: gradle?.dir ?? base.cwd,
path: project?.path ?? `:${module.split("/").join(":")}`,
};
}
export function produceDirectory(input: ContextInput): Produced | null {
input = scopedInput(input);
const { root } = input;
@@ -1334,25 +1314,13 @@ export function produceDirectory(input: ContextInput): Produced | null {
const base = closest(["gradle", "maven"]);
if (base) {
const module = jvmModuleDir(rel + "/x.java", input.configs);
// Gradle in a multi-module project: run from the build root so the
// wrapper (`./gradlew`) resolves, qualifying the task with the module's
// Gradle path (`services/api` → `:services:api:test`). Other builds run
// in the module directory as before.
const owner = gradleOwnerFor(module, base);
const moduleBase = { ...base, cwd: owner ? owner.dir : module || base.cwd };
const moduleArgs = (base: RunConfig): string[] => {
if (!owner) return [...base.args];
return base.args.map((a) => (a === "test" ? `${owner.path}:test` : a));
};
if (!jvmPackage) return make(moduleBase, "All Tests", moduleArgs(base));
// Maven runs in the module directory.
const moduleBase = base.kind === "gradle" ? inGradleModule(base, module) : { ...base, cwd: module || base.cwd };
if (!jvmPackage) return make(moduleBase, "All Tests", [...moduleBase.args]);
const pkg = jvmPackage[2]!.replace(/\//g, ".");
return base.kind === "gradle"
? make(moduleBase, `Tests in '${pkg}'`, [...moduleArgs(base), "--tests", `${pkg}.*`])
: make(moduleBase, `Tests in '${pkg}'`, [
...base.args,
`-Dtest=${pkg}.**.*`,
"-Dsurefire.failIfNoSpecifiedTests=false",
]);
? make(moduleBase, `Tests in '${pkg}'`, [...moduleBase.args, "--tests", `${pkg}.*`])
: make(moduleBase, `Tests in '${pkg}'`, withMavenTests(base.args, `${pkg}.**.*`));
}
}
const js = closest(["npm", "bun", "deno"]);
+23 -1
Переглянути файл
@@ -191,6 +191,17 @@ describe("rerunFailedConfig", () => {
expect(await rerunFailedConfig(cfg("zig", "zig", ["build", "test"]), [["tally", "subs"]])).toBeNull();
});
it("gradle: reruns and tree selections of a subproject's run keep its test task", async () => {
const run = cfg("gradle", "./gradlew", [":services:api:test", "--tests", "com.a.FooTest"]);
expect((await rerunFailedConfig(run, [["com.a.FooTest", "bar()"]]))!.args).toEqual([
":services:api:test",
"--tests",
"com.a.FooTest.bar",
]);
const [selected] = await testsConfigs(run, [["com.a.FooTest", "baz"]], "FooTest.baz");
expect(selected!.args).toEqual([":services:api:test", "--tests", "com.a.FooTest.baz"]);
});
it("gradle and maven filters", async () => {
expect((await rerunFailedConfig(cfg("gradle", "./gradlew", ["test"]), [["com.a.FooTest", "bar()"]]))!.args).toEqual(
["test", "--tests", "com.a.FooTest.bar"],
@@ -201,7 +212,18 @@ describe("rerunFailedConfig", () => {
["com.a.FooTest", "baz"],
["com.a.BarTest"],
]))!.args,
).toEqual(["test", "-Dtest=com.a.FooTest#bar+baz,com.a.BarTest"]);
).toEqual(["test", "-Dtest=com.a.FooTest#bar+baz,com.a.BarTest", "-Dsurefire.failIfNoSpecifiedTests=false"]);
});
it("maven: a rerun replaces the previous selection and lets modules without the tests pass", async () => {
const narrowed = cfg("maven", "./mvnw", ["test", "-Dtest=Old", "-Dsurefire.failIfNoSpecifiedTests=false"]);
expect((await rerunFailedConfig(narrowed, [["com.a.FooTest", "bar"]]))!.args).toEqual([
"test",
"-Dtest=com.a.FooTest#bar",
"-Dsurefire.failIfNoSpecifiedTests=false",
]);
const [selected] = await testsConfigs(cfg("maven", "mvn", ["test"]), [["com.a.FooTest", "baz"]], "FooTest.baz");
expect(selected!.args).toEqual(["test", "-Dtest=com.a.FooTest#baz", "-Dsurefire.failIfNoSpecifiedTests=false"]);
});
it("zig: --test-filter per failed test for `zig test`, null for build-based runs", async () => {
+2 -1
Переглянути файл
@@ -9,6 +9,7 @@ import { formatArgs, parseArgs } from "../configs";
import { appendScriptArgs } from "../scriptArgs";
import { djangoTestsOf } from "../djangoTypes";
import { goTestParts, withoutGoSelection } from "../goArguments";
import { withMavenTests } from "../mavenTests";
import { frameworkFor } from "./index";
import { dotnetFilter } from "./dotnet";
import { nodeStatus, type TestNode, type TestResults } from "./results";
@@ -134,7 +135,7 @@ function jvmArgs(config: RunConfig, paths: string[][]): string[] | null {
...[...byClass].map(([cls, ms]) => `${cls}#${unique(ms).join("+")}`),
...classes.filter((c) => !byClass.has(c)),
];
return [...config.args.filter((a) => !a.startsWith("-Dtest=")), `-Dtest=${specs.join(",")}`];
return withMavenTests(config.args, specs.join(","));
}
const filters = [...unique(tests.map((t) => `${t.cls}.${t.method}`)), ...classes];
return [...dropFlag(config.args, ["--tests"]), ...filters.flatMap((f) => ["--tests", f])];
+65 -6
Переглянути файл
@@ -1,17 +1,76 @@
.error {
color: var(--danger);
}
.color {
display: inline-flex;
.fileColorsLayout {
display: flex;
flex-direction: column;
gap: var(--space-3);
font-size: var(--fs-ui);
}
.colorOptions {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: var(--space-1-5);
column-gap: var(--space-4);
}
.colorOptions > * {
min-width: 0;
}
.colorRows {
height: clamp(144px, 30vh, 264px);
overflow: auto;
scroll-padding-top: var(--h-list-row);
}
.colorRows th {
position: sticky;
top: 0;
z-index: 1;
background: var(--bg-control);
border-bottom: 0;
box-shadow: inset 0 -1px var(--border);
}
.colorColumn {
width: 40%;
}
.scopeButton {
display: block;
width: 100%;
height: var(--h-list-row);
padding: 0;
border: 0;
background: none;
color: inherit;
font: inherit;
overflow: hidden;
text-align: start;
text-overflow: ellipsis;
white-space: nowrap;
}
.scopeButton:focus-visible {
outline-offset: -2px;
}
.colorRows .emptyColorRow:hover {
background: none;
}
.colorRows .emptyColorRow td {
white-space: normal;
overflow-wrap: anywhere;
}
.swatch {
flex: none;
width: 12px;
height: 12px;
display: inline-block;
width: calc(var(--space-4) + var(--space-2));
height: var(--space-3);
margin-inline-end: var(--space-2);
border-radius: 3px;
border: 1px solid var(--border-strong);
vertical-align: middle;
}
.colorDetail [role="radiogroup"] {
flex-wrap: wrap;
}
.colorDetail [role="radiogroup"] > * {
flex-shrink: 0;
max-width: 100%;
}
.custom {
display: inline-flex;
+57 -26
Переглянути файл
@@ -2,13 +2,13 @@
* Appearance & Behavior › Scopes (named file sets) and › File Colors (a background
* colour per scope in the project view and on editor tabs). Both are project settings.
*/
import { useId, useLayoutEffect, useRef, useState } from "react";
import { useCallback, useId, useLayoutEffect, useRef, useState } from "react";
import clsx from "clsx";
import { FILE_COLOR_NAMES, fileColorCss, validateFileColors, type FileColorEntry } from "@/platform/fileColors";
import { tx } from "@/platform/i18n";
import { BUILTIN_SCOPES, scopeError, validateScopes, type NamedScope } from "@/platform/scopes";
import { IconButton, Input, List, T, type SelectOption } from "@/ui";
import { ColorSwatches, Row, Section, Select } from "../components/Form";
import { ColorSwatches, Row, Section, Select, SettingToggle } from "../components/Form";
import { useSetting } from "../components/context";
import styles from "./Workflow.module.css";
import own from "./Scopes.module.css";
@@ -196,6 +196,9 @@ export function FileColorsEditor() {
const current = colors[index];
const set = (next: FileColorEntry[]) => setRaw({ ...settings, colors: next });
const update = (patch: Partial<FileColorEntry>) => set(colors.map((c, i) => (i === index ? { ...c, ...patch } : c)));
const revealRow = useCallback((row: HTMLTableRowElement | null) => {
row?.scrollIntoView({ block: "nearest", inline: "nearest" });
}, []);
const scopeNames = [...BUILTIN_SCOPES, ...validateScopes(rawScopes).map((s) => s.name)];
const scopeOptions: SelectOption[] = scopeNames.map((n) => ({ value: n, label: n }));
@@ -204,7 +207,12 @@ export function FileColorsEditor() {
const presets = FILE_COLOR_NAMES.map((n) => ({ value: n, label: colorLabel(n), css: fileColorCss(n) }));
return (
<div className={styles.toolsLayout}>
<div className={own.fileColorsLayout}>
<div className={own.colorOptions}>
<SettingToggle k="fileColors.enabled" label="Enable file colors" />
<SettingToggle k="fileColors.editorTabs" label="Use in editor tabs" disabled={!settings.enabled} />
<SettingToggle k="fileColors.projectView" label="Use in project view" disabled={!settings.enabled} />
</div>
<div className={styles.tableBox}>
<ListToolbar
label="File colors actions"
@@ -224,32 +232,55 @@ export function FileColorsEditor() {
}
}}
/>
<div className={styles.toolList} role="listbox" aria-label={tx("File colors")}>
{colors.length === 0 && (
<div className={clsx(styles.toolRow, styles.empty)}>
<T>No file colors. Click + to add one.</T>
</div>
)}
{colors.map((c, i) => (
<div
key={i}
role="option"
aria-selected={i === index}
className={clsx(styles.toolRow, i === index && styles.toolRowSelected)}
onMouseDown={() => setSelected(i)}
>
<span className={styles.toolName}>{tx(c.scope)}</span>
<span className={own.color}>
<span className={own.swatch} style={{ background: fileColorCss(c.color) }} aria-hidden />
{tx(colorLabel(c.color))}
</span>
</div>
))}
<div className={own.colorRows}>
<table className={styles.table} aria-label={tx("File colors")}>
<colgroup>
<col />
<col className={own.colorColumn} />
</colgroup>
<thead>
<tr>
<th scope="col">
<T>Scope</T>
</th>
<th scope="col">
<T>Color</T>
</th>
</tr>
</thead>
<tbody>
{colors.length === 0 && (
<tr className={own.emptyColorRow}>
<td colSpan={2} className={styles.empty}>
<T>No file colors. Click + to add one.</T>
</td>
</tr>
)}
{colors.map((c, i) => (
<tr
key={i}
ref={i === index ? revealRow : undefined}
className={clsx(i === index && styles.selectedRow)}
onClick={() => setSelected(i)}
>
<td>
<button type="button" className={own.scopeButton} title={tx(c.scope)} aria-pressed={i === index}>
{tx(c.scope)}
</button>
</td>
<td title={tx(colorLabel(c.color))}>
<span className={own.swatch} style={{ background: fileColorCss(c.color) }} aria-hidden />
{tx(colorLabel(c.color))}
</td>
</tr>
))}
</tbody>
</table>
</div>
</div>
{current && (
<Section title="File Color">
<Row label="Scope" className={styles.alignedRow}>
<Row label="Scope">
<Select
value={current.scope}
options={scopeOptions}
@@ -257,7 +288,7 @@ export function FileColorsEditor() {
aria-label="Scope"
/>
</Row>
<Row label="Color" className={styles.alignedRow}>
<Row label="Color" className={own.colorDetail}>
<ColorSwatches
value={current.color}
presets={presets}
+28
Переглянути файл
@@ -138,6 +138,34 @@
.table tbody tr.selectedRow {
background: var(--bg-tree-selected);
}
.saveActions {
display: flex;
flex-direction: column;
gap: var(--space-3);
font-size: var(--fs-ui);
}
.saveActionsTable th {
background: var(--bg-control);
}
.saveActionsTable td {
height: auto;
padding-block: var(--space-1);
vertical-align: top;
white-space: normal;
overflow-wrap: anywhere;
}
.saveActivationColumn {
width: 168px;
}
@container settings-content (width < 560px) {
.saveActivationColumn {
width: 120px;
}
}
.saveActivation {
padding-block-start: var(--space-0-5);
color: var(--fg-muted);
}
.mappingsTable {
height: 100%;
min-height: 0;
+44
Переглянути файл
@@ -34,6 +34,12 @@
align-items: center;
gap: var(--space-1-5);
}
.inlineChoices {
flex-wrap: wrap;
min-height: var(--h-field);
max-width: 100%;
gap: var(--space-1) var(--space-4);
}
.inlineLabel::after {
content: ":";
}
@@ -43,6 +49,26 @@
.inlineText {
width: 180px;
}
.checkWithField {
align-items: flex-start;
gap: var(--space-1) var(--space-2);
}
.checkWithField > label {
min-width: 0;
min-height: var(--h-field);
}
.inlineField {
display: flex;
flex-direction: column;
gap: var(--space-1);
width: 280px;
max-width: 100%;
}
.inlineFieldHint {
color: var(--fg-subtle);
font-size: var(--fs-small);
line-height: 1.4;
}
.suffix {
color: var(--fg);
}
@@ -92,6 +118,24 @@
flex-wrap: wrap;
gap: var(--space-1) var(--space-4);
}
.stackedRadioBlock,
.stackedRadios {
flex-direction: column;
align-items: flex-start;
}
.stackedRadioBlock {
margin-inline-end: 0;
}
.stackedRadios {
max-width: 100%;
}
.stackedRadios .radio {
max-width: 100%;
overflow-wrap: anywhere;
}
.stackedRadioBlock .radioLabel + .stackedRadios {
padding-inline-start: calc(var(--space-4) + var(--space-1));
}
.radio {
display: inline-flex;
align-items: center;
+129 -81
Переглянути файл
@@ -8,7 +8,7 @@
import { useEffect, useId, useState } from "react";
import clsx from "clsx";
import { commands, isTauri } from "@/platform/ipc";
import { Checkbox, Icon, type IconName } from "@/ui";
import { Checkbox, Icon, Radio, type IconName } from "@/ui";
import { SearchLabel, Select } from "../../components/Form";
import { useLabelMatch, useSearchQuery, useSetting } from "../../components/context";
import { labelMatches } from "../../model/pages";
@@ -90,6 +90,8 @@ function InlineCompletionLanguages() {
);
}
const WHEEL_ZOOM_LABEL = "Change font size with Ctrl/Command+Mouse Wheel";
const GENERAL = editorPage({
id: "editor.general",
title: "General",
@@ -120,31 +122,21 @@ const GENERAL = editorPage({
{
t: "check",
key: `${P}.general.wheelZoom`,
label: "Change font size with Ctrl/Command+Mouse Wheel",
inline: {
kind: "select",
key: `${P}.general.wheelZoomScope`,
options: [
{ value: "active", label: "Active editor" },
{ value: "all", label: "All editors" },
],
},
},
{ t: "check", key: `${P}.general.dragAndDrop`, label: "Enable drag-and-drop functionality in editor" },
],
},
{
title: "Scrolling",
items: [
{
t: "radio",
key: `${P}.general.caretScroll`,
label: "When caret is moved",
options: [
{ value: "center", label: "Prefer scrolling editor canvas to keep caret line centered" },
{ value: "minimize", label: "Prefer moving caret line to minimize editor scrolling" },
label: WHEEL_ZOOM_LABEL,
children: [
{
t: "radio",
key: `${P}.general.wheelZoomScope`,
label: WHEEL_ZOOM_LABEL,
layout: "options-only",
options: [
{ value: "active", label: "Active editor" },
{ value: "all", label: "All editors" },
],
},
],
},
{ t: "check", key: `${P}.general.dragAndDrop`, label: "Enable drag-and-drop functionality in editor" },
],
},
{
@@ -154,14 +146,14 @@ const GENERAL = editorPage({
t: "check",
key: `${P}.softWrap`,
label: "Soft-wrap files",
inline: {
kind: "text",
key: `${P}.general.softWrapFiles`,
label: "File patterns",
placeholder: "*.md; *.txt",
hint: "Use ; to separate patterns. * matches every file.",
},
children: [
{
t: "text",
key: `${P}.general.softWrapFiles`,
label: "File patterns",
placeholder: "*.md; *.txt",
hint: "Use ; to separate patterns. * matches every file.",
},
{ t: "check", key: `${P}.general.softWrapIndent`, label: "Use original line's indent for wrapped parts" },
],
},
@@ -171,6 +163,21 @@ const GENERAL = editorPage({
title: "Virtual Space",
items: [{ t: "check", key: `${P}.general.scrollPastEnd`, label: "Show virtual space at file bottom" }],
},
{
title: "Scrolling",
items: [
{
t: "radio",
key: `${P}.general.caretScroll`,
label: "When caret is moved",
layout: "stacked",
options: [
{ value: "center", label: "Prefer scrolling editor canvas to keep caret line centered" },
{ value: "minimize", label: "Prefer moving caret line to minimize editor scrolling" },
],
},
],
},
{
title: "Save Files",
items: [
@@ -370,6 +377,46 @@ const BREADCRUMBS = editorPage({
],
});
const COMPLETION_MATCH_CASE_LABEL = "Match case:";
const COMPLETION_CASE_OPTIONS = [
{ value: "first", label: "First letter only" },
{ value: "all", label: "All letters" },
] as const;
function CompletionMatchCase() {
const [matchCase, setMatchCase] = useSetting<boolean>(`${P}.completion.matchCase`);
const [caseSensitivity, setCaseSensitivity] = useSetting<string>(`${P}.completion.caseSensitivity`);
const selected = caseSensitivity === "all" ? "all" : "first";
const name = useId();
const matched = useLabelMatch(COMPLETION_MATCH_CASE_LABEL);
return (
<div className={clsx(styles.check, matched && styles.matched)} data-search-match={matched || undefined}>
<Checkbox
checked={!!matchCase}
onChange={setMatchCase}
label={<SearchLabel text={COMPLETION_MATCH_CASE_LABEL} />}
/>
<span
className={clsx(styles.inline, styles.inlineChoices)}
role="radiogroup"
aria-label={tx(COMPLETION_MATCH_CASE_LABEL)}
>
{COMPLETION_CASE_OPTIONS.map((option) => (
<Radio
key={option.value}
name={name}
checked={option.value === selected}
onChange={() => setCaseSensitivity(option.value)}
disabled={!matchCase}
label={<SearchLabel text={option.label} />}
/>
))}
</span>
</div>
);
}
const COMPLETION = editorPage({
id: "editor.general.codeCompletion",
title: "Code Completion",
@@ -379,17 +426,10 @@ const COMPLETION = editorPage({
{
items: [
{
t: "check",
key: `${P}.completion.matchCase`,
label: "Match case:",
inline: {
kind: "select",
key: `${P}.completion.caseSensitivity`,
options: [
{ value: "first", label: "First letter only" },
{ value: "all", label: "All letters" },
],
},
t: "custom",
label: COMPLETION_MATCH_CASE_LABEL,
keywords: COMPLETION_CASE_OPTIONS.map((option) => option.label),
component: CompletionMatchCase,
},
{
t: "check",
@@ -449,20 +489,29 @@ const FOLDING = editorPage({
order: 4,
keywords: ["fold", "collapse"],
sections: [
{ items: [{ t: "check", key: `${P}.folding.showOutline`, label: "Show code folding outline" }] },
{
items: [
{
t: "check",
key: `${P}.folding.showOutline`,
label: "Show code folding outline",
inline: {
kind: "select",
key: `${P}.folding.outlineVisibility`,
options: [
{ value: "hover", label: "On hover" },
{ value: "always", label: "Always" },
],
},
},
],
},
{
title: "Fold by default:",
items: [
{
t: "grid",
columns: [
[
{ t: "check", key: `${P}.folding.fileHeader`, label: "File header" },
{ t: "check", key: `${P}.folding.imports`, label: "Imports" },
],
[{ t: "check", key: `${P}.folding.docComments`, label: "Documentation comments" }],
],
},
{ t: "check", key: `${P}.folding.fileHeader`, label: "File header" },
{ t: "check", key: `${P}.folding.imports`, label: "Imports" },
{ t: "check", key: `${P}.folding.docComments`, label: "Documentation comments" },
],
},
],
@@ -727,12 +776,6 @@ const SMART_KEYS = editorPage({
{
items: [
{ t: "check", key: `${P}.smartKeys.smartHome`, label: "Home moves caret to first non-whitespace character" },
{
t: "check",
key: `${P}.smartKeys.camelHumps`,
label: 'Use "CamelHumps" words',
hint: "⌥← / ⌥→ and ⌥⌫ stop at humps of camelCase names.",
},
{
t: "check",
key: `${P}.smartKeys.pairBrackets`,
@@ -740,9 +783,36 @@ const SMART_KEYS = editorPage({
hint: "Also pairs <> for generics where the syntax says a type starts.",
},
{ t: "check", key: `${P}.smartKeys.pairQuotes`, label: "Insert pair quote" },
{
t: "check",
key: `${P}.smartKeys.camelHumps`,
label: 'Use "CamelHumps" words',
hint: "⌥← / ⌥→ and ⌥⌫ stop at humps of camelCase names.",
},
{ t: "check", key: `${P}.smartKeys.surroundSelection`, label: "Surround selection on typing quote or brace" },
{ t: "check", key: `${P}.smartKeys.tabOutOfPair`, label: "Jump outside closing bracket/quote with Tab" },
{ t: "check", key: `${P}.smartKeys.simultaneousTagEditing`, label: "Simultaneous <tag></tag> editing" },
],
},
{
title: "Enter",
items: [
{ t: "check", key: `${P}.smartKeys.smartIndent`, label: "Smart indent" },
{ t: "check", key: `${P}.smartKeys.insertDocStub`, label: "Insert documentation comment stub" },
],
},
{
items: [
{
t: "select",
key: `${P}.smartKeys.backspaceUnindent`,
label: "Unindent on Backspace",
options: [
{ value: "autoindent", label: "To proper indent position" },
{ value: "nearest", label: "To nearest indent position" },
{ value: "none", label: "Disabled" },
],
},
{
t: "select",
key: `${P}.smartKeys.reformatOnPaste`,
@@ -760,28 +830,6 @@ const SMART_KEYS = editorPage({
},
],
},
{
title: "Enter",
items: [
{ t: "check", key: `${P}.smartKeys.smartIndent`, label: "Smart indent" },
{ t: "check", key: `${P}.smartKeys.insertDocStub`, label: "Insert documentation comment stub" },
],
},
{
title: "Backspace",
items: [
{
t: "select",
key: `${P}.smartKeys.backspaceUnindent`,
label: "Unindent",
options: [
{ value: "autoindent", label: "To proper indent position" },
{ value: "nearest", label: "To nearest indent position" },
{ value: "none", label: "Disabled" },
],
},
],
},
],
});
+50 -8
Переглянути файл
@@ -7,7 +7,7 @@
*/
import { createContext, useContext, useId, type ComponentType, type ReactNode } from "react";
import clsx from "clsx";
import { Checkbox, Input, type SelectOption } from "@/ui";
import { Checkbox, Input, T, type SelectOption } from "@/ui";
import { executeAction } from "@/platform/actions";
import { tx } from "@/platform/i18n";
import { NumberInput, Row, SearchLabel, Section, Select } from "../../components/Form";
@@ -17,7 +17,8 @@ import styles from "./Editor.module.css";
export type Inline =
| { kind: "number"; key: string; min: number; max: number; unit?: string; suffix?: string }
| { kind: "select"; key: string; options: readonly SelectOption[]; suffix?: string };
| { kind: "select"; key: string; options: readonly SelectOption[]; suffix?: string }
| { kind: "text"; key: string; label: string; placeholder?: string; hint?: string };
export type Item =
| {
@@ -35,7 +36,14 @@ export type Item =
}
| { t: "number"; key: string; label: string; min: number; max: number; unit?: string; hint?: ReactNode }
| { t: "select"; key: string; label: string; options: readonly SelectOption[]; hint?: ReactNode }
| { t: "radio"; key: string; label: string; options: readonly SelectOption[]; hint?: ReactNode }
| {
t: "radio";
key: string;
label: string;
options: readonly SelectOption[];
layout?: "stacked" | "options-only";
hint?: ReactNode;
}
| { t: "text"; key: string; label: string; placeholder?: string; hint?: ReactNode; wide?: boolean }
| { t: "grid"; columns: Item[][] }
| { t: "custom"; label: string; keywords?: string[]; component: ComponentType }
@@ -65,11 +73,17 @@ function CheckItem({ item }: { item: Extract<Item, { t: "check" }> }) {
const context = usePageContext();
const [raw, set] = useSetting<boolean>(item.key);
const checked = item.invert ? !raw : !!raw;
const matched = useLabelMatch(item.label);
const inlineText = item.inline?.kind === "text" ? item.inline : undefined;
const labelMatched = useLabelMatch(item.label);
const fieldMatched = useLabelMatch(inlineText?.label);
const matched = labelMatched || fieldMatched;
const off = parentDisabled || !checked;
return (
<>
<div className={clsx(styles.check, matched && styles.matched)} data-search-match={matched || undefined}>
<div
className={clsx(styles.check, inlineText && styles.checkWithField, matched && styles.matched)}
data-search-match={matched || undefined}
>
<Checkbox
checked={checked}
disabled={parentDisabled}
@@ -98,9 +112,32 @@ function CheckItem({ item }: { item: Extract<Item, { t: "check" }> }) {
function InlineControl({ inline, label, disabled }: { inline: Inline; label: string; disabled: boolean }) {
if (inline.kind === "number") return <InlineNumber inline={inline} label={label} disabled={disabled} />;
if (inline.kind === "text") return <InlineText inline={inline} disabled={disabled} />;
return <InlineSelect inline={inline} label={label} disabled={disabled} />;
}
function InlineText({ inline, disabled }: { inline: Extract<Inline, { kind: "text" }>; disabled: boolean }) {
const [value, set] = useSetting<string>(inline.key);
const hintId = useId();
return (
<div className={styles.inlineField}>
<Input
aria-label={inline.label}
aria-describedby={inline.hint ? hintId : undefined}
disabled={disabled}
value={value}
placeholder={inline.placeholder}
onChange={(event) => set(event.target.value)}
/>
{inline.hint && (
<div id={hintId} className={styles.inlineFieldHint}>
<T>{inline.hint}</T>
</div>
)}
</div>
);
}
function InlineNumber({
inline,
label,
@@ -201,13 +238,17 @@ function RadioItem({ item }: { item: Extract<Item, { t: "radio" }> }) {
const name = useId();
const matched = useLabelMatch(item.label);
return (
<div className={clsx(styles.radioBlock, matched && styles.matched)} role="radiogroup" aria-label={item.label}>
{item.label && (
<div
className={clsx(styles.radioBlock, item.layout && styles.stackedRadioBlock, matched && styles.matched)}
role="radiogroup"
aria-label={tx(item.label)}
>
{item.label && item.layout !== "options-only" && (
<div className={clsx(styles.radioLabel, disabled && styles.dim)}>
<SearchLabel text={item.label} />:
</div>
)}
<div className={styles.radios}>
<div className={clsx(styles.radios, item.layout && styles.stackedRadios)}>
{item.options.map((o) => (
<label key={o.value} className={clsx(styles.radio, disabled && styles.dim)}>
<input
@@ -302,6 +343,7 @@ export function itemLabels(items: readonly Item[]): string[] {
if (it.t === "custom") out.push(...(it.keywords ?? []));
if (it.t === "select" || it.t === "radio") out.push(...it.options.map((o) => o.label));
if (it.t === "check" && it.inline?.kind === "select") out.push(...it.inline.options.map((o) => o.label));
if (it.t === "check" && it.inline?.kind === "text") out.push(it.inline.label);
if (it.t === "check" && it.children) out.push(...itemLabels(it.children));
}
}
+9 -8
Переглянути файл
@@ -15,19 +15,20 @@ export const SCOPE_PAGES: PageSpec[] = [
defaultScope: "project",
keywords: ["colour", "color", "tab", "background", "tests", "non-project"],
sections: [
{
options: [
{ kind: "toggle", key: "fileColors.enabled", label: "Enable file colors" },
{ kind: "toggle", key: "fileColors.editorTabs", label: "Use in editor tabs" },
{ kind: "toggle", key: "fileColors.projectView", label: "Use in project view" },
],
},
{
options: [
{
kind: "custom",
label: "File Colors",
keywords: ["Scope", "Color", "Custom", "Hex value"],
keywords: [
"Enable file colors",
"Use in editor tabs",
"Use in project view",
"Scope",
"Color",
"Custom",
"Hex value",
],
component: FileColorsEditor,
},
],
+73 -44
Переглянути файл
@@ -16,7 +16,7 @@ import {
type ExternalToolValid,
} from "@/platform/workflowSettings";
import { Button, Checkbox, IconButton, Input, Menu, type SelectOption, T } from "@/ui";
import { NumberInput, Row, SearchLabel, Section, Select, SettingSelect } from "../components/Form";
import { NumberInput, Row, SearchLabel, Section, Select, SettingSelect, Toggle } from "../components/Form";
import { useLabelMatch, useSetting } from "../components/context";
import { selectPage, setQuery } from "../model/staging";
import { MirrorPrefixRow } from "./DownloadSources";
@@ -344,40 +344,75 @@ function TerminalFont() {
// ---------------------------------------------------------------------------
// Actions on Save
function ActionsOnSave() {
const SAVE_ACTIONS = [
{
k: "editor.formatOnSave",
label: "Reformat code",
hint: "Formats the whole file with the language server's formatter.",
},
{
k: "actionsOnSave.optimizeImports",
label: "Optimize imports",
hint: "Runs the language server's Organize Imports action.",
},
{
k: "actionsOnSave.cleanup",
label: "Run code cleanup",
hint: "Applies the language server's fix-all action (source.fixAll).",
},
];
function SaveActionRow({ k, label, hint }: (typeof SAVE_ACTIONS)[number]) {
const [enabled, setEnabled] = useSetting<boolean>(k);
return (
<>
<BoundToggle
k="editor.formatOnSave"
label="Reformat code"
hint="Formats the whole file with the language server's formatter."
/>
<BoundToggle
k="actionsOnSave.optimizeImports"
label="Optimize imports"
hint="Runs the language server's Organize Imports action."
/>
<BoundToggle
k="actionsOnSave.cleanup"
label="Run code cleanup"
hint="Applies the language server's fix-all action (source.fixAll)."
/>
</>
<tr>
<td>
<Toggle label={label} hint={hint} checked={!!enabled} onChange={setEnabled} />
</td>
<td>
{enabled && (
<div className={styles.saveActivation}>
<T>Save or Save All</T>
</div>
)}
</td>
</tr>
);
}
function ActionsOnSaveNote() {
function ActionsOnSave() {
return (
<div className={styles.note}>
<T>
{
"Actions run when a file is saved with Save (⌘S) or Save All. Trailing spaces and the final line break are configured in"
}
</T>{" "}
<PageLink page="editor.general">
<T>Editor › General</T>
</PageLink>
.
<div className={styles.saveActions}>
<div className={styles.tableBox}>
<table className={clsx(styles.table, styles.saveActionsTable)} aria-label={tx("Actions on Save")}>
<colgroup>
<col />
<col className={styles.saveActivationColumn} />
</colgroup>
<thead>
<tr>
<th scope="col">
<T>Action</T>
</th>
<th scope="col">
<T>Activated on</T>
</th>
</tr>
</thead>
<tbody>
{SAVE_ACTIONS.map((action) => (
<SaveActionRow key={action.k} {...action} />
))}
</tbody>
</table>
</div>
<div className={styles.note}>
<T>Trailing spaces and the final line break are configured in</T>{" "}
<PageLink page="editor.general">
<T>Editor › General</T>
</PageLink>
.
</div>
</div>
);
}
@@ -657,21 +692,15 @@ export const TOOLS_PAGES: PageSpec[] = [
group: TOOLS_GROUP,
order: 601,
projectScope: true,
keywords: ["save", "format on save", "reformat", "organize imports", "cleanup"],
sections: [
{
title: "Activate on Save",
options: [
{
kind: "custom",
label: "Reformat code",
keywords: ["Optimize imports", "Run code cleanup"],
component: ActionsOnSave,
},
],
},
{ options: [{ kind: "custom", label: "Save", component: ActionsOnSaveNote }] },
keywords: [
"save",
"format on save",
"reformat",
"organize imports",
"cleanup",
...SAVE_ACTIONS.map((a) => a.label),
],
component: ActionsOnSave,
},
{
id: "tools.externalDiff",
+132 -48
Переглянути файл
@@ -1,73 +1,157 @@
/** Settings › Editor › Postfix Completion. */
import { useMemo, useState } from "react";
import { useCallback, useMemo, useState } from "react";
import clsx from "clsx";
import { Checkbox, T } from "@/ui";
import { POSTFIX_GROUPS, POSTFIX_TEMPLATES } from "../postfix/model";
import { listNavigate } from "@/ui/List";
import { expandTemplate } from "../live/model";
import { POSTFIX_GROUPS, POSTFIX_TEMPLATES, type PostfixTemplate } from "../postfix/model";
import { setPostfixTemplateEnabled, updatePostfixSettings, usePostfixSettings } from "../postfix/store";
import styles from "./Settings.module.css";
import { tx } from "@/platform/i18n";
const EXAMPLE_EXPRESSION = "expr";
function PostfixPreview({ template }: { template: PostfixTemplate }) {
const preview = expandTemplate(template, {
predefined: { EXPR: EXAMPLE_EXPRESSION, TYPE: "Type", PAT: "pattern" },
}).preview;
return (
<section className={styles.postfixPreview} aria-label={tx("Template preview")}>
<div className={styles.postfixDescription}>
<code>.{template.key}</code>
<span>{template.description}</span>
</div>
<div>
<span>
<T>Before</T>
</span>
<pre>
<code>
{EXAMPLE_EXPRESSION}.{template.key}
</code>
</pre>
</div>
<div>
<span>
<T>{template.action ? "Fallback expansion" : "After"}</T>
</span>
<pre>
<code>{preview}</code>
</pre>
</div>
</section>
);
}
export function PostfixPage() {
const settings = usePostfixSettings();
const disabled = useMemo(() => new Set(settings.disabled), [settings.disabled]);
const [group, setGroup] = useState(POSTFIX_GROUPS[0]!.id);
const [selections, setSelections] = useState<Record<string, string>>({});
const list = POSTFIX_TEMPLATES.filter((t) => t.id.startsWith(`${group}.`));
const selectedIndex = Math.max(
0,
list.findIndex((t) => t.id === selections[group]),
);
const selected = list[selectedIndex];
const select = (id: string) => setSelections((current) => ({ ...current, [group]: id }));
const revealSelected = useCallback((button: HTMLButtonElement | null) => {
button?.scrollIntoView?.({ block: "nearest", inline: "nearest" });
}, []);
return (
<div className={styles.page}>
<div className={styles.options}>
<div className={styles.postfixOptions}>
<Checkbox
checked={settings.enabled}
onChange={(v) => updatePostfixSettings({ enabled: v })}
label="Enable postfix completion"
/>
<Checkbox
checked={settings.expandWithTab}
disabled={!settings.enabled}
onChange={(v) => updatePostfixSettings({ expandWithTab: v })}
label="Expand templates with Tab"
/>
<Checkbox
checked={settings.showInCompletion}
disabled={!settings.enabled}
onChange={(v) => updatePostfixSettings({ showInCompletion: v })}
label="Show postfix templates in code completion"
/>
<div className={styles.postfixDependentOptions}>
<Checkbox
checked={settings.showInCompletion}
disabled={!settings.enabled}
onChange={(v) => updatePostfixSettings({ showInCompletion: v })}
label="Show postfix templates in code completion"
/>
<Checkbox
checked={settings.expandWithTab}
disabled={!settings.enabled}
onChange={(v) => updatePostfixSettings({ expandWithTab: v })}
label="Expand templates with Tab"
/>
</div>
</div>
<div className={styles.hint}>
<T>Type an expression followed by</T> <code>.key</code>, e.g. <code>user.name.nn</code> or{" "}
<code>items.for</code>
<T>, then press Tab.</T>
</div>
<div className={styles.tabs} role="tablist" aria-label={tx("Languages")}>
{POSTFIX_GROUPS.map((g) => (
<button
key={g.id}
type="button"
role="tab"
aria-selected={g.id === group}
className={clsx(styles.tab, g.id === group && styles.tabActive)}
onClick={() => setGroup(g.id)}
>
{g.title}
</button>
))}
</div>
<div className={styles.list} role="list" aria-label={tx("Postfix templates")}>
{list.map((t) => (
<div key={t.id} className={styles.listRow} role="listitem">
<Checkbox
checked={!disabled.has(t.id)}
disabled={!settings.enabled}
onChange={(v) => setPostfixTemplateEnabled(t.id, v)}
aria-label={tx`Enable .${t.key}`}
/>
<span className={styles.mono}>.{t.key}</span>
<span className={styles.itemDetail} title={t.description}>
{t.description}
</span>
{settings.enabled && settings.expandWithTab && (
<div className={styles.hint}>
<T>Type an expression followed by</T> <code>.key</code>, e.g. <code>user.name.nn</code> or{" "}
<code>items.for</code>
<T>, then press Tab.</T>
</div>
)}
<div className={styles.postfixWorkspace}>
<div className={styles.postfixBrowser}>
<div className={styles.tabs} role="tablist" aria-label={tx("Languages")}>
{POSTFIX_GROUPS.map((g) => (
<button
key={g.id}
type="button"
role="tab"
aria-selected={g.id === group}
className={clsx(styles.tab, g.id === group && styles.tabActive)}
onClick={() => setGroup(g.id)}
>
{g.title}
</button>
))}
</div>
))}
<div
className={styles.list}
role="list"
aria-label={tx("Postfix templates")}
onKeyDown={(event) => {
const next = listNavigate(event.key, { items: list, active: selectedIndex });
if (next === null) return;
event.preventDefault();
const template = list[next];
if (!template) return;
select(template.id);
event.currentTarget.querySelectorAll("button")[next]?.focus();
}}
>
{list.map((t) => {
const active = t.id === selected?.id;
return (
<div key={t.id} className={clsx(styles.listRow, active && styles.itemSelected)} role="listitem">
<Checkbox
checked={!disabled.has(t.id)}
disabled={!settings.enabled}
tabIndex={active ? undefined : -1}
onChange={(v) => {
select(t.id);
setPostfixTemplateEnabled(t.id, v);
}}
aria-label={tx`Enable .${t.key}`}
/>
<button
type="button"
ref={active ? revealSelected : undefined}
className={styles.postfixChoice}
tabIndex={active ? 0 : -1}
aria-label={`.${t.key}`}
aria-pressed={active}
title={t.description}
onClick={() => select(t.id)}
>
<span className={styles.mono}>.{t.key}</span>
<span className={styles.itemDetail}>{t.description}</span>
</button>
</div>
);
})}
</div>
</div>
{selected && <PostfixPreview template={selected} />}
</div>
</div>
);
+102 -3
Переглянути файл
@@ -173,11 +173,40 @@
gap: var(--space-1-5);
justify-content: flex-end;
}
.postfixOptions,
.postfixDependentOptions {
display: flex;
flex-direction: column;
align-items: flex-start;
gap: var(--space-1);
}
.postfixDependentOptions {
padding-inline-start: calc(var(--space-4) + var(--space-2));
}
.postfixWorkspace {
display: grid;
grid-template-columns: minmax(0, 1fr) minmax(0, 1.15fr);
flex: 1;
min-height: 320px;
border: 1px solid var(--border-strong);
border-radius: var(--radius-small);
overflow: hidden;
}
.postfixBrowser {
display: flex;
flex-direction: column;
min-height: 0;
min-width: 0;
border-inline-end: 1px solid var(--border);
}
.postfixBrowser .tabs {
flex: none;
padding: var(--space-1);
border-bottom: 1px solid var(--border);
}
.list {
display: flex;
flex-direction: column;
border: 1px solid var(--border-strong);
border-radius: var(--radius-small);
overflow: auto;
flex: 1;
min-height: 0;
@@ -185,13 +214,83 @@
.listRow {
display: flex;
align-items: center;
gap: 10px;
gap: var(--space-2);
min-height: var(--h-row);
padding: 0 8px;
}
.listRow:hover {
background: var(--bg-hover);
}
.listRow.itemSelected {
background: var(--bg-selected);
}
.listRow.itemSelected .itemDetail {
color: var(--fg);
}
.postfixChoice {
display: flex;
align-items: center;
gap: var(--space-2);
flex: 1;
min-width: 0;
height: var(--h-row);
padding: 0;
border: 0;
background: none;
color: inherit;
font: inherit;
text-align: start;
}
.postfixChoice:focus-visible {
outline-offset: -2px;
}
.postfixPreview {
display: flex;
flex-direction: column;
gap: var(--space-4);
min-width: 0;
overflow: auto;
padding: var(--space-3);
}
.postfixDescription {
display: flex;
align-items: baseline;
flex-wrap: wrap;
gap: var(--space-1) var(--space-2);
overflow-wrap: anywhere;
color: var(--fg-strong);
}
.postfixDescription code,
.postfixPreview pre {
font-family: var(--font-mono);
}
.postfixPreview pre {
margin: var(--space-1) 0 0;
padding: var(--space-2);
border: 1px solid var(--border);
border-radius: var(--radius-small);
background: var(--bg-app);
color: var(--fg-emphasis);
font-size: var(--fs-code);
line-height: var(--lh-code);
white-space: pre-wrap;
overflow-wrap: anywhere;
tab-size: 4;
}
@container settings-content (width < 600px) {
.postfixWorkspace {
grid-template-columns: minmax(0, 1fr);
flex: none;
min-height: 0;
}
.postfixBrowser {
border-inline-end: 0;
border-bottom: 1px solid var(--border);
}
.postfixBrowser .list {
max-height: clamp(128px, 24vh, 192px);
}
}
.mono {
font-family: var(--font-mono);
color: var(--fg-emphasis);
+21
Переглянути файл
@@ -24,6 +24,9 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
};
});
const openUrl = vi.hoisted(() => vi.fn(async (_url: string) => undefined));
vi.mock("../issueLinks", () => ({ openUrl }));
import { openOnRemoteActions, registerOpenOnRemote } from "../openOnRemote";
import { useVcs } from "../store";
@@ -127,6 +130,24 @@ describe("Copy Path/Reference… › <hosting> Link", () => {
});
});
it("opens the file on its remote at the selected lines from Open In", async () => {
await start();
const open = (ctx: Parameters<typeof menuGroupItems>[1]) =>
menuGroupItems("openIn", ctx).filter((i): i is Item => i.kind !== "separator" && "run" in i)[0]!;
open({ paths: ["/p/src/a.ts"], line: 9, endLine: 19 }).run!();
await vi.waitFor(() =>
expect(openUrl).toHaveBeenLastCalledWith(
"https://gitlab.example.com/group/sub/app/-/blob/feature/x/src/a.ts#L10-20",
),
);
open({ paths: ["/p/src/a.ts"], line: 9 }).run!();
await vi.waitFor(() =>
expect(openUrl).toHaveBeenLastCalledWith(
"https://gitlab.example.com/group/sub/app/-/blob/feature/x/src/a.ts#L10",
),
);
});
it("warns instead of copying when the file has no page on a remote", async () => {
await executeAction("vcs.copyRemoteLink", { path: "/elsewhere/a.ts", line: 0 });
await vi.waitFor(() =>
+61
Переглянути файл
@@ -0,0 +1,61 @@
import { beforeEach, expect, it, vi } from "vitest";
import type { FileStatus } from "@/bindings";
const mocks = vi.hoisted(() => ({
notify: vi.fn(),
executeAction: vi.fn(),
apply: vi.fn(),
}));
vi.mock("@/platform/actions", async (original) => ({
...(await original<typeof import("@/platform/actions")>()),
executeAction: mocks.executeAction,
}));
vi.mock("@/workbench/contributions", async (original) => ({
...(await original<typeof import("@/workbench/contributions")>()),
notifications: () => ({ notify: mocks.notify, expire: vi.fn() }),
maybeEditorService: () => null,
}));
vi.mock("@/platform/ipc", async (original) => {
const real = await original<typeof import("@/platform/ipc")>();
const ok = (data: unknown) => Promise.resolve({ status: "ok" as const, data });
return {
...real,
commands: { ...real.commands, vcsStashApply: mocks.apply, vcsStashes: () => ok([]) },
};
});
import { applyStash } from "../changeOps";
import { useVcs } from "../store";
const file = (relPath: string, unstaged: FileStatus["unstaged"]): FileStatus => ({
path: `/p/${relPath}`,
relPath,
staged: null,
unstaged,
renamedFrom: null,
});
beforeEach(() => {
vi.clearAllMocks();
mocks.apply.mockResolvedValue({
status: "error",
error: { kind: "io", message: "CONFLICT (content): Merge conflict in src/a.txt" },
});
useVcs.setState({ root: "/p", repo: "/p", roots: ["/p"], available: false, status: [] });
});
it("opens the Conflicts dialog instead of an error when the unstashed changes conflict", async () => {
useVcs.setState({ status: [file("src/a.txt", "conflicted")] });
await applyStash(1, true, "/p");
expect(mocks.executeAction).toHaveBeenCalledWith("vcs.resolveConflicts");
expect(mocks.notify).not.toHaveBeenCalledWith(expect.objectContaining({ level: "error" }));
});
it("still reports an unstash that failed without conflicts", async () => {
useVcs.setState({ status: [file("src/a.txt", "modified")] });
await applyStash(0, false, "/p");
expect(mocks.executeAction).not.toHaveBeenCalledWith("vcs.resolveConflicts");
expect(mocks.notify).toHaveBeenCalledWith(
expect.objectContaining({ level: "error", title: "Apply stash@{0} failed" }),
);
});
+2 -1
Переглянути файл
@@ -15,7 +15,7 @@ import { RepoPicker, useBranchInfo } from "./gitMenuDialogs";
import { baseName, effectiveKind, stripSlash } from "./model";
import { logConsole, runOp, saveAll } from "./ops";
import { ensureCommitIdentity } from "./commitIdentity";
import { showCompareRevisions } from "./operations";
import { conflictsInstead, showCompareRevisions } from "./operations";
import { FileChecklist } from "./shelf";
import { currentRepo, loadStashes, refreshNow, useVcs } from "./store";
import styles from "./common.module.css";
@@ -442,6 +442,7 @@ export async function unstash(o: UnstashOptions, repo = currentRepo()) {
const { title, success } = unstashTitles(o);
await runOp(title, () => call(commands.vcsStashApply(repo, o.index, o.pop, o.reinstateIndex, o.branch)), {
success,
onError: conflictsInstead,
});
void loadStashes().catch((e) => logConsole("err", String(e)));
}
+5 -5
Переглянути файл
@@ -1,7 +1,7 @@
/**
* Open In › GitHub / GitLab / Bitbucket: the file (at the caret line) or directory on the web UI
* Open In › GitHub / GitLab / Bitbucket: the file (at the selected lines) or directory on the web UI
* of its repository's remote, at the current branch's upstream (else the HEAD commit).
* Copy Path/Reference… › <hosting> Link copies that page's address, with the selected lines.
* Copy Path/Reference… › <hosting> Link copies that page's address.
*/
import { executeAction, type Action } from "@/platform/actions";
import { writeClipboardText } from "@/platform/clipboard";
@@ -133,9 +133,9 @@ export function registerOpenOnRemote(): () => void {
const url = root ? remoteUrls.get(root) : null;
const hosting = url ? remoteHosting(url) : null;
if (!root || !hosting) return [];
const target: Target = { path, dir: dirs?.[0] ?? false, line };
const target: Target = { path, dir: dirs?.[0] ?? false, line, endLine };
if (menu === "copyPath") {
const page = pageFor({ ...target, endLine }, root, url);
const page = pageFor(target, root, url);
if (!page) return [];
return [
{
@@ -143,7 +143,7 @@ export function registerOpenOnRemote(): () => void {
label: tx`${hosting.name} Link`,
verbatim: true,
preview: page,
run: () => void executeAction("vcs.copyRemoteLink", { ...target, endLine }),
run: () => void executeAction("vcs.copyRemoteLink", target),
},
];
}
+8 -1
Переглянути файл
@@ -143,7 +143,13 @@ export const EDITOR_EXTRA_DEFAULTS = {
parameterInfoDelay: 1000,
},
autoImport: { addUnambiguous: false, optimizeOnTheFly: false, importsOnPaste: "ask" as "ask" | "always" | "never" },
folding: { showOutline: true, fileHeader: true, imports: true, docComments: false },
folding: {
showOutline: true,
outlineVisibility: "hover" as "hover" | "always",
fileHeader: true,
imports: true,
docComments: false,
},
tabs: {
placement: "top",
multipleRows: false,
@@ -278,6 +284,7 @@ export function validateEditorExtras(raw: unknown): EditorExtras {
const out = coerceLike(raw, EDITOR_EXTRA_DEFAULTS);
if (!["active", "all"].includes(out.general.wheelZoomScope)) out.general.wheelZoomScope = "active";
if (!["ask", "always", "never"].includes(out.autoImport.importsOnPaste)) out.autoImport.importsOnPaste = "ask";
if (!["hover", "always"].includes(out.folding.outlineVisibility)) out.folding.outlineVisibility = "hover";
if (!DOCSTRING_FORMATS.includes(out.docstringFormat)) out.docstringFormat = "rest";
for (const k of ["codeVisionUsagesPosition", "codeVisionAuthorPosition"] as const)
if (!["top", "right"].includes(out.inlay[k])) out.inlay[k] = "top";
+10
Переглянути файл
@@ -1,6 +1,7 @@
{
"Open diff as editor tab": "Open diff as editor tab",
"When off, diffs you open (changes, history, Compare) show in a separate window.": "When off, diffs you open (changes, history, Compare) show in a separate window.",
"On hover": "On hover",
"Plain-text word lists (one word per line) or Hunspell .dic files; a .dic with its .aff beside it also accepts the inflected forms and compounds its rules allow. Relative paths resolve against the project root, ~/ against the home folder.": "Plain-text word lists (one word per line) or Hunspell .dic files; a .dic with its .aff beside it also accepts the inflected forms and compounds its rules allow. Relative paths resolve against the project root, ~/ against the home folder.",
"Trust Folder": "Trust Folder",
"No files selected": "No files selected",
@@ -513,6 +514,7 @@
"Inlay hint preview": "Inlay hint preview",
"Inlay hint categories": "Inlay hint categories",
"Parameter": "Parameter",
"Unindent on Backspace": "Unindent on Backspace",
"Global variable": "Global variable",
"Package reference": "Package reference",
"Constant": "Constant",
@@ -1457,6 +1459,11 @@
"More actions for {name}": "More actions for {name}",
"More actions…": "More actions…",
"Actions for {name}": "Actions for {name}",
"Action": "Action",
"Actions on Save": "Actions on Save",
"Activated on": "Activated on",
"Save or Save All": "Save or Save All",
"Trailing spaces and the final line break are configured in": "Trailing spaces and the final line break are configured in",
"Configure MCP Server": "Configure MCP Server",
"Add MCP Server": "Add MCP Server",
"User (Global settings)": "User (Global settings)",
@@ -1678,6 +1685,8 @@
"New Project": "New Project",
"{path} already exists and is not empty": "{path} already exists and is not empty",
"Example": "Example",
"Template preview": "Template preview",
"Fallback expansion": "Fallback expansion",
"Shows how to use the plugin API; not maintained as a product.": "Shows how to use the plugin API; not maintained as a product.",
"{count} downloads": "{count} downloads",
"This plugin shows how to use the plugin API and is not maintained as a product. Build on it in your own repository.": "This plugin shows how to use the plugin API and is not maintained as a product. Build on it in your own repository.",
@@ -1834,6 +1843,7 @@
"Open Editors": "Open Editors",
"Enter Folder": "Enter Folder",
"Click to edit": "Click to edit",
"Compute the value": "Compute the value",
"Show less": "Show less",
"Show {more} more lines": "Show {more} more lines",
"Terminal": "Terminal",
+3 -2
Переглянути файл
@@ -178,8 +178,9 @@
"Action id (bind it in Keymap)": "ID de acción (asígnalo en Mapa de teclado)",
"Actions": "Acciones",
"Actions on Save": "Acciones al guardar",
"Actions run when a file is saved with Save (⌘S) or Save All. Trailing spaces and the final line break are configured in": "Las acciones se ejecutan cuando se guarda un archivo con Guardar (⌘S) o Guardar todo. Los espacios finales y el salto de línea final se configuran en",
"Activate on Save": "Activar al guardar",
"Trailing spaces and the final line break are configured in": "Los espacios finales y el salto de línea final se configuran en",
"Activated on": "Se activa al",
"Save or Save All": "Guardar o Guardar todo",
"Activate virtualenv": "Activar virtualenv",
"Add": "Agregar",
"Add Column": "Agregar columna",
+3 -2
Переглянути файл
@@ -132,8 +132,9 @@
"Action id (bind it in Keymap)": "Identifiant de l'action (à associer dans les raccourcis clavier)",
"Actions": "Actions",
"Actions on Save": "Actions à l'enregistrement",
"Actions run when a file is saved with Save (⌘S) or Save All. Trailing spaces and the final line break are configured in": "Actions exécutées lorsqu'un fichier est enregistré avec Enregistrer (⌘S) ou Tout enregistrer. Les espaces de fin de ligne et le saut de ligne final se configurent dans",
"Activate on Save": "Activer à l'enregistrement",
"Trailing spaces and the final line break are configured in": "Les espaces de fin de ligne et le saut de ligne final se configurent dans",
"Activated on": "Déclenché par",
"Save or Save All": "Enregistrer ou Tout enregistrer",
"Activate virtualenv": "Activer l'environnement virtuel",
"Add": "Ajouter",
"Add Column": "Ajouter une colonne",
+3 -2
Переглянути файл
@@ -213,8 +213,9 @@
"Action id (bind it in Keymap)": "액션 ID(키맵에서 바인딩)",
"Actions": "액션",
"Actions on Save": "저장 시 액션",
"Actions run when a file is saved with Save (⌘S) or Save All. Trailing spaces and the final line break are configured in": "저장(⌘S) 또는 모두 저장으로 파일을 저장할 때 실행되는 액션입니다. 후행 공백과 마지막 줄 바꿈은 다음에서 구성합니다:",
"Activate on Save": "저장 시 활성화",
"Trailing spaces and the final line break are configured in": "후행 공백과 마지막 줄 바꿈은 다음에서 구성합니다:",
"Activated on": "실행 시점",
"Save or Save All": "저장 또는 모두 저장",
"Activate virtualenv": "virtualenv 활성화",
"Add": "추가",
"Add Column": "열 추가",
+3 -2
Переглянути файл
@@ -170,8 +170,9 @@
"Action id (bind it in Keymap)": "Identyfikator akcji (przypisz go w Mapie skrótów)",
"Actions": "Akcje",
"Actions on Save": "Akcje podczas zapisywania",
"Actions run when a file is saved with Save (⌘S) or Save All. Trailing spaces and the final line break are configured in": "Akcje uruchamiane podczas zapisywania pliku za pomocą Zapisz (⌘S) lub Zapisz wszystko. Końcowe spacje i końcowy znak końca wiersza są konfigurowane w",
"Activate on Save": "Aktywuj przy zapisie",
"Trailing spaces and the final line break are configured in": "Końcowe spacje i końcowy znak końca wiersza są konfigurowane w",
"Activated on": "Uruchamianie",
"Save or Save All": "Zapisz lub Zapisz wszystko",
"Activate virtualenv": "Aktywuj środowisko virtualenv",
"Add": "Dodaj",
"Add Column": "Dodaj kolumnę",
+3 -2
Переглянути файл
@@ -170,8 +170,9 @@
"Action id (bind it in Keymap)": "ID da ação (vincule-a no Mapa de teclas)",
"Actions": "Ações",
"Actions on Save": "Ações ao salvar",
"Actions run when a file is saved with Save (⌘S) or Save All. Trailing spaces and the final line break are configured in": "Ações executadas quando um arquivo é salvo com Salvar (⌘S) ou Salvar tudo. Espaços finais e quebra de linha final são configurados em",
"Activate on Save": "Ativar ao salvar",
"Trailing spaces and the final line break are configured in": "Espaços finais e quebra de linha final são configurados em",
"Activated on": "Ativado em",
"Save or Save All": "Salvar ou Salvar tudo",
"Activate virtualenv": "Ativar virtualenv",
"Add": "Adicionar",
"Add Column": "Adicionar coluna",
+8 -2
Переглянути файл
@@ -1,6 +1,7 @@
{
"Open diff as editor tab": "以编辑器标签页打开差异",
"When off, diffs you open (changes, history, Compare) show in a separate window.": "关闭后,打开的差异(更改、历史记录、比较)会显示在单独的窗口中。",
"On hover": "悬停时",
"Plain-text word lists (one word per line) or Hunspell .dic files; a .dic with its .aff beside it also accepts the inflected forms and compounds its rules allow. Relative paths resolve against the project root, ~/ against the home folder.": "纯文本单词列表(每行一个词)或 Hunspell .dic 文件;旁边有同名 .aff 的 .dic 还会接受其规则允许的变形和复合词。相对路径基于项目根目录解析,~/ 表示主目录。",
"MCP server instructions": "MCP 服务器说明",
"MCP tools (deferred)": "MCP 工具(延迟加载)",
@@ -456,6 +457,7 @@
"Inlay hint preview": "嵌入提示预览",
"Inlay hint categories": "嵌入提示类别",
"Parameter": "参数",
"Unindent on Backspace": "按退格键取消缩进",
"Package reference": "包引用",
"Instance field": "实例字段",
"Static symbol": "静态符号",
@@ -775,8 +777,9 @@
"Action id (bind it in Keymap)": "操作 ID(可在“按键映射”中绑定)",
"Actions": "操作",
"Actions on Save": "保存时操作",
"Actions run when a file is saved with Save (⌘S) or Save All. Trailing spaces and the final line break are configured in": "使用“保存”(⌘S) 或“全部保存”保存文件时运行的操作。尾随空格和末尾换行符的配置位置:",
"Activate on Save": "保存时激活",
"Trailing spaces and the final line break are configured in": "在此配置尾随空格和末尾换行符:",
"Activated on": "触发方式",
"Save or Save All": "保存或全部保存",
"Activate virtualenv": "激活 virtualenv",
"Add": "添加",
"Add Column": "添加列",
@@ -2194,6 +2197,8 @@
"Postfix Completion": "后缀补全",
"Poetry Environment": "Poetry 环境",
"Postfix templates": "后缀模板",
"Template preview": "模板预览",
"Fallback expansion": "备用展开结果",
"Prefer": "首选",
"Prefer moving caret line to minimize editor scrolling": "优先移动光标所在行,以尽量减少编辑器滚动",
"Prefer scrolling editor canvas to keep caret line centered": "优先滚动编辑器画布,使光标所在行保持居中",
@@ -6773,6 +6778,7 @@
"Not set": "未设置",
"Replace…": "替换…",
"Value of {label}": "{label} 的值",
"Compute the value": "计算该值",
"The plugin can only send these with its network requests; it cannot read them.": "插件只能在网络请求中发送这些值,无法读取它们。",
"Editor Providers": "编辑器提供者",
"Translations": "翻译",