дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-22 17:40:45 +02:00
Порівняти коміти
23
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
e091561937 | ||
|
|
423bf2c733 | ||
|
|
73d1470940 | ||
|
|
c83b0b1442 | ||
|
|
d16993e175 | ||
|
|
5d4cdac3c7 | ||
|
|
9c414cc75c | ||
|
|
3bbc90d750 | ||
|
|
6d157c8b71 | ||
|
|
f2c0fcdc96 | ||
|
|
a4574fdc92 | ||
|
|
4bc87f5d84 | ||
|
|
39671ff55b | ||
|
|
881812547d | ||
|
|
9c145ea258 | ||
|
|
4f192a12bc | ||
|
|
1d857375dc | ||
|
|
6543cdb36b | ||
|
|
684c92ce90 | ||
|
|
9a77a95180 | ||
|
|
1000ef0fa0 | ||
|
|
654da3e1ef | ||
|
|
ba6ccaf9b2 |
No files matched your search
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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>,
|
||||
|
||||
@@ -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 ¶ms["token"] {
|
||||
Value::String(s) => s.clone(),
|
||||
other => other.to_string(),
|
||||
};
|
||||
let token = progress_key(¶ms["token"]);
|
||||
let value = ¶ms["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);
|
||||
|
||||
@@ -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())]);
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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(|_| ())
|
||||
})
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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();
|
||||
|
||||
|
||||
@@ -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");
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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" },
|
||||
]);
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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");
|
||||
});
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
||||
Бінарний файл не відображається.
@@ -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();
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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. */
|
||||
|
||||
@@ -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
|
||||
? [
|
||||
|
||||
@@ -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({
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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)",
|
||||
|
||||
@@ -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 }),
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
@@ -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"));
|
||||
|
||||
@@ -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 };
|
||||
}
|
||||
@@ -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", () => {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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": {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
});
|
||||
@@ -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}` };
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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 });
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -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");
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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)),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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)),
|
||||
};
|
||||
}
|
||||
@@ -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"],
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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":
|
||||
|
||||
@@ -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];
|
||||
}
|
||||
@@ -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", () => {
|
||||
|
||||
@@ -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"]);
|
||||
|
||||
@@ -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 () => {
|
||||
|
||||
@@ -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])];
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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" },
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
},
|
||||
],
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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>
|
||||
);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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(() =>
|
||||
|
||||
@@ -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" }),
|
||||
);
|
||||
});
|
||||
@@ -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)));
|
||||
}
|
||||
|
||||
@@ -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),
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
@@ -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";
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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": "열 추가",
|
||||
|
||||
@@ -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ę",
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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": "翻译",
|
||||
|
||||
Reference in new issue
Заблокувати користувача