дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-22 17:40:45 +02:00
Порівняти коміти
38
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
e091561937 | ||
|
|
423bf2c733 | ||
|
|
73d1470940 | ||
|
|
c83b0b1442 | ||
|
|
d16993e175 | ||
|
|
5d4cdac3c7 | ||
|
|
9c414cc75c | ||
|
|
3bbc90d750 | ||
|
|
6d157c8b71 | ||
|
|
f2c0fcdc96 | ||
|
|
a4574fdc92 | ||
|
|
4bc87f5d84 | ||
|
|
39671ff55b | ||
|
|
881812547d | ||
|
|
9c145ea258 | ||
|
|
4f192a12bc | ||
|
|
1d857375dc | ||
|
|
6543cdb36b | ||
|
|
684c92ce90 | ||
|
|
9a77a95180 | ||
|
|
1000ef0fa0 | ||
|
|
654da3e1ef | ||
|
|
ba6ccaf9b2 | ||
|
|
3ec631f0c0 | ||
|
|
f64796607c | ||
|
|
5baaf5b7de | ||
|
|
95f88f6ffb | ||
|
|
06b7c3a826 | ||
|
|
e9335f032d | ||
|
|
d09fdc8c7e | ||
|
|
54e69973c8 | ||
|
|
91d37aa4bf | ||
|
|
e149ba2ab3 | ||
|
|
fc6de7d0e4 | ||
|
|
76ef8c9b05 | ||
|
|
0344553652 | ||
|
|
cf15013b49 | ||
|
|
eb985cda28 |
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,8 @@ use std::collections::BTreeMap;
|
||||
pub struct VcsSettings {
|
||||
/// Colour folders that contain changed files (project tree, tabs).
|
||||
pub show_dirty_directories: bool,
|
||||
/// Diffs the user opens show in an editor tab; off, in a separate window.
|
||||
pub diff_as_editor_tab: bool,
|
||||
/// Stop file history (Show History) after `history_limit` commits.
|
||||
pub limit_history: bool,
|
||||
pub history_limit: u32,
|
||||
@@ -55,6 +57,7 @@ impl Default for VcsSettings {
|
||||
Self {
|
||||
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
|
||||
show_dirty_directories: false,
|
||||
diff_as_editor_tab: true,
|
||||
limit_history: true,
|
||||
history_limit: 1000,
|
||||
git: GitSettings::default(),
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -145,30 +145,38 @@ impl ClickhousePool {
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
if !rejects_driver_setting(&error) {
|
||||
let Some(setting) = rejected_driver_setting(&error) else {
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if !use_http_session {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
if setting == "readonly" {
|
||||
return Err(error);
|
||||
}
|
||||
if !source.read_only {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; enable Read-only for independent queries on a strict read-only server",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Every request still sends readonly=1, regardless of which node answers.
|
||||
pool.0.session.lock().await.strict_read_only = true;
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
} else {
|
||||
// Only rely on the server's write protection after proving strict read-only
|
||||
// in this same named session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// The rejected probe may have opened a session on a different node.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
@@ -236,7 +244,7 @@ impl ClickhousePool {
|
||||
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -324,7 +332,7 @@ impl ClickhousePool {
|
||||
result
|
||||
}
|
||||
None => {
|
||||
let killed = self.kill(&client, &query_id).await;
|
||||
let killed = self.kill(&client, &query_id, &session).await;
|
||||
match killed {
|
||||
Ok(()) => Err(IdeError::cancelled()),
|
||||
Err(error) => Err(IdeError::new(
|
||||
@@ -336,15 +344,16 @@ impl ClickhousePool {
|
||||
}
|
||||
}
|
||||
|
||||
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
|
||||
let response = client
|
||||
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
|
||||
let mut request = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.timeout(Duration::from_secs(3))
|
||||
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
|
||||
.send()
|
||||
.await
|
||||
.map_err(http_error)?;
|
||||
.timeout(Duration::from_secs(3));
|
||||
if self.0.read_only && session.id.is_none() {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
let response =
|
||||
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
|
||||
let status = response.status();
|
||||
let code = response
|
||||
.headers()
|
||||
@@ -551,13 +560,14 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.is_some_and(|(name, _)| {
|
||||
.map(|(name, _)| name)
|
||||
.filter(|&name| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
@@ -953,19 +963,77 @@ mod tests {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
async fn strict_stateless_connections_keep_readonly_on_every_request() {
|
||||
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
|
||||
let (port, requests) = server(vec![
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
|
||||
("200 OK", "", ONE),
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "fixture_database".into(),
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
|
||||
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
|
||||
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
|
||||
let result = pool.execute(sql, 1, &cancel).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
|
||||
assert!(result.has_more);
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("SELECT 1"));
|
||||
assert!(requests[2].ends_with(write));
|
||||
assert!(requests[3].ends_with(sql));
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name}");
|
||||
}
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
|
||||
for (read_only, detail, body) in [
|
||||
(
|
||||
false,
|
||||
"enable Read-only",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
)])
|
||||
.await;
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'readonly'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'max_threads'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
] {
|
||||
let (port, requests) =
|
||||
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
assert!(error.message.contains(detail), "{}", error.message);
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
@@ -1041,7 +1109,7 @@ mod tests {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1084,37 +1152,45 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancellation_sends_kill_outside_the_busy_session() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
|
||||
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
assert!(!kill.contains("session_id="));
|
||||
for stateless in [false, true] {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) =
|
||||
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let source = DataSource {
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let query_id = query_value(&request_url(&query), "query_id").unwrap();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
let url = request_url(&kill);
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -303,7 +303,9 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(3);
|
||||
|
||||
fn cancel_timeout() -> IdeError {
|
||||
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
|
||||
IdeError::invalid(
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
|
||||
)
|
||||
}
|
||||
|
||||
async fn exchange(
|
||||
|
||||
@@ -210,9 +210,13 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
})
|
||||
.await
|
||||
.expect("driver cancellation must be bounded");
|
||||
assert!(result.unwrap_err().message.contains("Reconnect"));
|
||||
db.disconnect("test").await;
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(
|
||||
result.unwrap_err().message,
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
|
||||
);
|
||||
assert!(db.connected().is_empty());
|
||||
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(db.connected(), ["test"]);
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -1049,12 +1049,14 @@ impl LspManager {
|
||||
if let Err(e) = peer.notify("initialized", json!({})) {
|
||||
tracing::warn!("{}: {e}", server.name);
|
||||
}
|
||||
// Servers that don't ask with `workspace/configuration` only learn settings this way.
|
||||
let cfg = server.effective_config();
|
||||
if cfg.settings.is_some()
|
||||
&& let Err(e) =
|
||||
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
|
||||
{
|
||||
// Sent even without settings: servers that don't ask with `workspace/configuration`
|
||||
// only learn settings this way, and Pyright, given workspace folders, waits for it
|
||||
// before asking and loading the workspace.
|
||||
let mut settings = handler::all_settings(&server.effective_config());
|
||||
if settings.is_null() {
|
||||
settings = json!({});
|
||||
}
|
||||
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
|
||||
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
|
||||
}
|
||||
|
||||
|
||||
@@ -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};
|
||||
@@ -1324,6 +1324,36 @@ async fn initialize_and_incremental_sync() {
|
||||
assert_eq!(infos[0].status, ServerStatus::Ready);
|
||||
}
|
||||
|
||||
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
|
||||
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn every_server_hears_its_configuration_once_initialized() {
|
||||
let cases = [
|
||||
(None, None, json!({})),
|
||||
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
|
||||
(
|
||||
None,
|
||||
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
|
||||
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
|
||||
),
|
||||
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
|
||||
];
|
||||
for (init, settings, expected) in cases {
|
||||
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
|
||||
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
|
||||
cfg.settings = settings.clone();
|
||||
});
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("pyright", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("pyright");
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
|
||||
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
|
||||
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn full_sync_and_desync_recovery() {
|
||||
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
|
||||
@@ -2152,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())]);
|
||||
@@ -2650,7 +2725,16 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
|
||||
.await;
|
||||
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
|
||||
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
|
||||
assert_eq!(
|
||||
methods,
|
||||
[
|
||||
"initialized",
|
||||
"workspace/didChangeConfiguration",
|
||||
"textDocument/didOpen",
|
||||
"textDocument/didChange",
|
||||
"textDocument/didSave"
|
||||
]
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
@@ -2706,9 +2790,9 @@ async fn settings_changes_reach_servers_without_restarts() {
|
||||
let s = h.launcher.state("mock");
|
||||
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
|
||||
h.mgr.reconfigure().await;
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
|
||||
assert_eq!(
|
||||
s.notified("workspace/didChangeConfiguration")[0],
|
||||
s.notified("workspace/didChangeConfiguration")[1],
|
||||
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
|
||||
@@ -462,35 +462,54 @@ fn main() {
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires ty on PATH"]
|
||||
async fn ty_python_end_to_end() {
|
||||
python_server_end_to_end("ty").await;
|
||||
}
|
||||
|
||||
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires pyright-langserver on PATH"]
|
||||
async fn pyright_python_end_to_end() {
|
||||
python_server_end_to_end("pyright").await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires basedpyright on PATH"]
|
||||
async fn basedpyright_python_end_to_end() {
|
||||
python_server_end_to_end("basedpyright").await;
|
||||
}
|
||||
|
||||
/// Definition and diagnostics from `name` alone, in a project without configuration.
|
||||
async fn python_server_end_to_end(name: &str) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
let path = root.join("example.py");
|
||||
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
|
||||
python.language_servers.retain(|server| server.name == "ty");
|
||||
python.language_servers.retain(|server| server.name == name);
|
||||
assert_eq!(python.language_servers.len(), 1);
|
||||
python.language_servers[0].fallback = false;
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
|
||||
retry("ty ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "ty");
|
||||
retry(&format!("{name} ready"), Duration::from_secs(30), || {
|
||||
let status = last_status(&events, name);
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("ty failed: {msg:?}");
|
||||
panic!("{name} failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
let defs = retry("ty definition", Duration::from_secs(30), || {
|
||||
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(defs[0].path, path);
|
||||
assert_eq!(defs[0].range.start.line, 0);
|
||||
retry("ty diagnostics", Duration::from_secs(30), || {
|
||||
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
|
||||
let found = events.lock().iter().any(
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
|
||||
);
|
||||
async move { found.then_some(()) }
|
||||
})
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -372,6 +372,8 @@ fn materialize_row(
|
||||
if let Some((pos, total)) = position {
|
||||
commit.log_position = Some(pos);
|
||||
commit.log_total = Some(total);
|
||||
let merge_time_ms = row.merge_time_secs as f64 * 1000.0;
|
||||
commit.log_merge_time_ms = (merge_time_ms > commit.commit_time_ms).then_some(merge_time_ms);
|
||||
}
|
||||
if !summary_only {
|
||||
commit.message = index.message(repo, row.id)?;
|
||||
@@ -714,17 +716,16 @@ fn log_indexed_rows(
|
||||
skip -= 1;
|
||||
continue;
|
||||
}
|
||||
let parents: Vec<ObjectId> = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
} else if let Some((ps, _)) = visibility.index.nodes.get(&id) {
|
||||
ps.clone()
|
||||
let (parents, commit_time_secs) = if let Some((parents, time)) = visibility.index.nodes.get(&id) {
|
||||
(parents.clone(), *time)
|
||||
} else {
|
||||
let record = visibility.index.get_with_table(&repo, id, visibility.table)?;
|
||||
record
|
||||
let parents = record
|
||||
.parents
|
||||
.iter()
|
||||
.map(|p| ObjectId::from_hex(p.as_bytes()).map_err(gx))
|
||||
.collect::<IdeResult<Vec<_>>>()?
|
||||
.collect::<IdeResult<Vec<_>>>()?;
|
||||
(parents, (record.commit_time_ms / 1000.0) as i64)
|
||||
};
|
||||
let shown_parents = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
@@ -743,6 +744,7 @@ fn log_indexed_rows(
|
||||
graph_parents: shown_parents,
|
||||
on_current_branch,
|
||||
history_path: history_paths.get(&id).cloned(),
|
||||
merge_time_secs: commit_time_secs,
|
||||
});
|
||||
if out.len() >= limit || stop_id == Some(id) {
|
||||
break;
|
||||
|
||||
@@ -125,6 +125,9 @@ pub struct Commit {
|
||||
pub log_position: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_total: Option<u32>,
|
||||
/// Newest committer time at or after this row if newer than the row's commit.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_merge_time_ms: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub graph_boundary_parents: Vec<String>,
|
||||
/// Reachability from HEAD, computed independently of the visible filters.
|
||||
|
||||
@@ -28,6 +28,7 @@ pub(crate) struct IndexedRow {
|
||||
pub graph_parents: Vec<ObjectId>,
|
||||
pub on_current_branch: bool,
|
||||
pub history_path: Option<String>,
|
||||
pub merge_time_secs: i64,
|
||||
}
|
||||
|
||||
pub(crate) struct IndexedView {
|
||||
@@ -35,8 +36,15 @@ pub(crate) struct IndexedView {
|
||||
pub positions: HashMap<ObjectId, usize>,
|
||||
}
|
||||
impl IndexedView {
|
||||
pub fn new(rows: Vec<IndexedRow>) -> Self {
|
||||
let positions = rows.iter().enumerate().map(|(i, r)| (r.id, i)).collect();
|
||||
pub fn new(mut rows: Vec<IndexedRow>) -> Self {
|
||||
let mut positions = HashMap::with_capacity(rows.len());
|
||||
let mut latest = i64::MIN;
|
||||
// Compute priority across the whole log so it stays the same on every page.
|
||||
for (i, row) in rows.iter_mut().enumerate().rev() {
|
||||
latest = latest.max(row.merge_time_secs);
|
||||
row.merge_time_secs = latest;
|
||||
positions.insert(row.id, i);
|
||||
}
|
||||
Self { rows, positions }
|
||||
}
|
||||
}
|
||||
@@ -341,6 +349,7 @@ impl LogIndex {
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
log_merge_time_ms: None,
|
||||
graph_boundary_parents: Vec::new(),
|
||||
refs: Vec::new(),
|
||||
});
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -83,6 +83,28 @@ fn incoming_order_groups_the_merged_branch_before_the_main_parent() {
|
||||
assert_eq!(out[1].parents, vec![h.c2.clone(), h.s1.clone()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_older_incoming_tip_uses_the_later_commit_time_when_merging_repo_pages() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"], None);
|
||||
let base = commit(dir, "base.txt", "base", 1000);
|
||||
let recent = commit(dir, "recent.txt", "recent", 4000);
|
||||
git(dir, &["checkout", "-qb", "incoming", &base], None);
|
||||
let incoming = commit(dir, "incoming.txt", "incoming", 2000);
|
||||
git(dir, &["checkout", "-q", "main"], None);
|
||||
let repo = Repo::discover(dir).unwrap().unwrap();
|
||||
let query = LogQuery { summary_only: true, order: LogOrder::Standard, limit: 1, ..Default::default() };
|
||||
|
||||
let first = repo.log(&query).unwrap();
|
||||
assert_eq!(first[0].id, incoming);
|
||||
assert_eq!(first[0].commit_time_ms, 2_000_000.0);
|
||||
assert_eq!(first[0].log_merge_time_ms, Some(4_000_000.0));
|
||||
let next = repo.log(&LogQuery { skip: 1, ..query }).unwrap();
|
||||
assert_eq!(next[0].id, recent);
|
||||
assert_eq!(next[0].log_merge_time_ms, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_merges_links_children_to_the_merge_parents() {
|
||||
let h = history();
|
||||
|
||||
@@ -172,11 +172,13 @@ The export button offers **Export Data…** and quick copies: **Copy as CSV**, *
|
||||
|
||||
The built-in HTTP driver uses a named session by default (`use_http_session=true`). Route requests to one node or enable session affinity. If the session expires or another node reports code 372, OpenIDEA shows a reconnect error and never replays the statement.
|
||||
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request; result-limit settings remain enabled.
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request.
|
||||
|
||||
Stateless statements must be independent: `USE`, standalone `SET`, temporary tables and other session state cannot carry over to later requests. Configure the database and settings on the data source. Startup scripts and explicit session properties (`session_id`, `session_check`, `session_timeout`) are rejected. SQL transactions and statement caching are unsupported in either mode.
|
||||
|
||||
Strict read-only servers that refuse per-request driver settings cannot use stateless mode: the connection fails without dropping read-only protection or limits. The strict read-only fallback requires proof in the same named HTTP session, including on subsequent requests; use one node or session affinity.
|
||||
For strict read-only accounts behind a load balancer, set `use_http_session=false` and enable **Read-only**. If the initial connection check receives ClickHouse code 164 for a driver-managed result setting, OpenIDEA repeats the check without its result-limit and JSON number-format settings. Each request still sends `readonly=1`, and the grid still retains only the requested page. Configure server-side limits in the account's settings profile. With the server's default JSON settings, `NaN` and infinities may appear as `NULL`.
|
||||
|
||||
Use consistent account profiles across replicas. If the first node accepts the driver's result settings and a later node rejects them, OpenIDEA reports the error on that request. Connect again after aligning the profiles.
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -171,11 +171,13 @@ SQL 补全基于已连接的架构:`FROM`/`JOIN` 后补全表(并根据外
|
||||
|
||||
内置 HTTP 驱动默认使用命名会话(`use_http_session=true`)。请求应路由到同一节点,或启用会话亲和性。如果会话过期或其他节点返回代码 372,OpenIDEA 会提示重新连接,且不会重放语句。
|
||||
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`;结果行数限制设置也会保留。
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`。
|
||||
|
||||
无会话模式下,每条语句必须独立:`USE`、独立的 `SET`、临时表及其他会话状态无法延续到后续请求。请在数据源中配置数据库和设置。驱动会拒绝启动脚本以及显式会话属性(`session_id`、`session_check`、`session_timeout`)。两种模式均不支持 SQL 事务和语句缓存。
|
||||
|
||||
拒绝逐请求驱动设置的严格只读服务器无法使用无会话模式:连接会失败,不会移除只读保护或限制。严格只读回退必须在同一个命名 HTTP 会话中验证,后续请求也必须使用该会话;请使用单一节点或会话亲和性。
|
||||
对于负载均衡器后的严格只读账户,请设置 `use_http_session=false` 并启用 **只读**。如果初次连接检查因驱动管理的结果设置收到 ClickHouse 错误码 164,OpenIDEA 会省略驱动的结果行数限制和 JSON 数字格式设置,再进行一次连接检查。每个请求仍会发送 `readonly=1`,结果表格仍只保留所请求的一页。请在账户的设置配置文件中配置服务端限制。使用服务器的默认 JSON 设置时,`NaN` 和无穷值可能显示为 `NULL`。
|
||||
|
||||
请在各副本上使用一致的账户设置配置文件。如果第一个节点接受驱动的结果设置,后续节点拒绝这些设置,OpenIDEA 会报告该请求的错误。调整配置文件使其一致后再连接。
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
@@ -60,7 +60,21 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
await editor.locator(".cm-line", { hasText: "return order.toDto()" }).click();
|
||||
await page.keyboard.press("End");
|
||||
await page.keyboard.press("Enter");
|
||||
await page.keyboard.type("order.");
|
||||
await page.keyboard.type("order");
|
||||
const firstPlacement = await page.evaluateHandle(() => {
|
||||
const sample: { labelX?: number } = {};
|
||||
const observer = new MutationObserver(() => {
|
||||
const label = document.querySelector(
|
||||
":is(.cm-tooltip-above, .cm-tooltip-below).cm-lsp-completion .cm-completionLabel",
|
||||
);
|
||||
if (!label) return;
|
||||
sample.labelX = label.getBoundingClientRect().left;
|
||||
observer.disconnect();
|
||||
});
|
||||
observer.observe(document.body, { subtree: true, attributes: true, attributeFilter: ["class"] });
|
||||
return sample;
|
||||
});
|
||||
await page.keyboard.type(".");
|
||||
await page.keyboard.press("Control+Space");
|
||||
const popup = page.locator(".cm-tooltip-autocomplete");
|
||||
await expect(popup.getByText("total", { exact: true })).toBeVisible();
|
||||
@@ -83,6 +97,8 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
});
|
||||
const label = await method.locator(".cm-completionLabel").boundingBox();
|
||||
// Subpixel rounding differs per platform/font; a mis-set inset is a whole icon column off.
|
||||
const firstLabelX = await firstPlacement.evaluate((sample) => sample.labelX!);
|
||||
expect(Math.abs(firstLabelX - wordStart)).toBeLessThanOrEqual(2);
|
||||
expect(Math.abs(label!.x - wordStart)).toBeLessThanOrEqual(2);
|
||||
const zoomedSize = await editor.locator(".cm-content").evaluate(async (content) => {
|
||||
const viewModule = "/node_modules/.vite/deps/@codemirror_view.js";
|
||||
|
||||
@@ -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,67 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.fileTemplates");
|
||||
});
|
||||
});
|
||||
|
||||
test("file template fields and editors fit in narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const style = page.getByRole("button", { name: "File name style" });
|
||||
const body = page.getByRole("textbox", { name: "Template body", exact: true });
|
||||
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await body.boundingBox())!.width).toBeGreaterThan(150);
|
||||
await expect(extension).toBeInViewport({ ratio: 0.98 });
|
||||
await expect(style).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await extension.boundingBox())!.y).toBeGreaterThan((await name.boundingBox())!.y);
|
||||
expect((await style.boundingBox())!.y).toBeGreaterThan((await extension.boundingBox())!.y);
|
||||
await style.click();
|
||||
await expect(page.getByRole("option", { name: "PascalCase" })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
for (const [tab, editorName] of [
|
||||
["Includes", "Include body"],
|
||||
["Code", "Code template body"],
|
||||
]) {
|
||||
await tabs.getByRole("tab", { name: tab, exact: true }).click();
|
||||
await expect(page.getByRole("textbox", { name: editorName, exact: true })).toBeInViewport({ ratio: 0.98 });
|
||||
}
|
||||
});
|
||||
|
||||
test("file template tabs share a remembered, keyboard-adjustable divider", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const divider = page.getByRole("separator", { name: "Resize file template panes" });
|
||||
const width = async (listName: string) =>
|
||||
(await page.getByRole("listbox", { name: listName, exact: true }).boundingBox())!.width;
|
||||
|
||||
await expect(divider).toBeVisible();
|
||||
expect((await extension.boundingBox())!.y).toBe((await name.boundingBox())!.y);
|
||||
const initial = await width("File templates");
|
||||
await divider.press("ArrowRight");
|
||||
await expect.poll(() => width("File templates")).toBeGreaterThan(initial + 10);
|
||||
const resized = await width("File templates");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Files", exact: true }).press("ArrowRight");
|
||||
await expect(tabs.getByRole("tab", { name: "Includes", exact: true })).toBeFocused();
|
||||
await expect.poll(() => width("Includes")).toBeCloseTo(resized, 0);
|
||||
await page.getByRole("button", { name: "Add Include" }).click();
|
||||
const include = page.getByRole("textbox", { name: "Include body" });
|
||||
await include.fill("// Shared header");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Code", exact: true }).click();
|
||||
await expect.poll(() => width("Code templates")).toBeCloseTo(resized, 0);
|
||||
await tabs.getByRole("tab", { name: "Includes", exact: true }).click();
|
||||
await page.getByRole("option", { name: "New Include", exact: true }).click();
|
||||
await expect(include).toHaveValue("// Shared header");
|
||||
});
|
||||
@@ -0,0 +1,93 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(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("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
});
|
||||
|
||||
test("inlay hint categories and the preview fit at both settings widths", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
await expect(preview).toBeVisible();
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await categories.boundingBox())!;
|
||||
const widePreview = (await preview.boundingBox())!;
|
||||
expect(widePreview.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(widePreview.y).toBeLessThan(wideList.y + wideList.height);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await categories.press("End");
|
||||
await expect(categories.getByRole("option", { name: /^Other hints/ })).toHaveAttribute("aria-selected", "true");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
const narrowList = (await categories.boundingBox())!;
|
||||
const narrowPreview = (await preview.boundingBox())!;
|
||||
expect(narrowPreview.y).toBeGreaterThan(narrowList.y + narrowList.height);
|
||||
await expect(preview).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
});
|
||||
|
||||
test("the hint preview follows staged settings and saves the selected category", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const master = dialog.getByRole("checkbox", { name: "Show inlay hints", exact: true });
|
||||
const parameters = dialog.getByRole("checkbox", { name: "Parameter names", exact: true });
|
||||
const parameterHint = preview.getByText("width:", { exact: true });
|
||||
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(categories.getByRole("option", { name: "Parameter names", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await expect(parameterHint).toBeVisible();
|
||||
await master.uncheck();
|
||||
await expect(parameters).toBeDisabled();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show Code Vision", exact: true })).toBeEnabled();
|
||||
await master.check();
|
||||
await expect(parameterHint).toBeVisible();
|
||||
|
||||
await parameters.uncheck();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await categories.press("Home");
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
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();
|
||||
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(parameters).not.toBeChecked();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
});
|
||||
|
||||
test("the hint preview respects the sample language's staged preference", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.languages = () => [
|
||||
{ id: "go", name: "Go" },
|
||||
{ id: "rust", name: "Rust" },
|
||||
];
|
||||
});
|
||||
await page.keyboard.press("Meta+,");
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const typeHint = preview.getByText(": f64", { exact: true });
|
||||
await expect(typeHint).toBeVisible();
|
||||
await dialog.getByRole("checkbox", { name: "Rust", exact: true }).uncheck();
|
||||
await expect(typeHint).toHaveCount(0);
|
||||
await dialog.getByRole("listbox", { name: "Inlay hint categories" }).press("End");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -133,3 +133,20 @@ test("rectangular drag remains configurable after removal and saves a middle mou
|
||||
await expect(row).toContainText("Middle Click");
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
|
||||
test("the action search also finds actions by typed shortcut text", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("treeitem", { name: "Keymap", exact: true }).click();
|
||||
const search = settings.getByRole("textbox", { name: "Search actions", exact: true });
|
||||
const actions = settings.getByRole("tree", { name: "Actions" });
|
||||
const goToFile = actions.getByRole("treeitem", { name: /Go to File/ });
|
||||
for (const query of ["cmd+shift+o", "Shift+Meta+O", "⇧⌘O"]) {
|
||||
await search.fill(query);
|
||||
await expect(goToFile).toBeVisible();
|
||||
await expect(actions.getByRole("treeitem", { name: /Recent Files/ })).toHaveCount(0);
|
||||
}
|
||||
const shots = process.env.OPENIDEA_E2E_SHOTS;
|
||||
if (shots) await settings.screenshot({ path: `${shots}/after.png`, animations: "disabled" });
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
@@ -0,0 +1,73 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(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("Notifications");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
});
|
||||
|
||||
test("notification group controls stay inside narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const groups = page.getByRole("region", { name: "Groups", exact: true });
|
||||
const popup = groups.getByRole("button", { name: "System Messages popup type" });
|
||||
await expect(popup).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await groups.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
const list = groups.getByRole("listbox", { name: "Notification groups" });
|
||||
const controls = groups.getByRole("region", { name: "System Messages", exact: true });
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
expect((await controls.boundingBox())!.y).toBeGreaterThanOrEqual(listBounds.y + listBounds.height);
|
||||
await popup.click();
|
||||
await expect(page.getByRole("option", { name: "Sticky balloon", exact: true })).toBeInViewport();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
await list.press("End");
|
||||
const lastGroup = list.getByRole("option", { name: "Distraction Free Mode", exact: true });
|
||||
await expect(lastGroup).toHaveAttribute("aria-selected", "true");
|
||||
await expect(lastGroup).toBeInViewport({ ratio: 0.98 });
|
||||
await list.press("Home");
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await list.boundingBox())!;
|
||||
const wideControls = (await controls.boundingBox())!;
|
||||
expect(wideControls.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(wideControls.y).toBeLessThan(wideList.y + wideList.height);
|
||||
});
|
||||
|
||||
test("notification groups follow settings search and keep edits per group", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const list = dialog.getByRole("listbox", { name: "Notification groups" });
|
||||
const systemPopup = dialog.getByRole("button", { name: "System Messages popup type" });
|
||||
const versionControlPopup = dialog.getByRole("button", { name: "Version Control popup type" });
|
||||
const versionControlLog = dialog.getByRole("checkbox", { name: "Show Version Control in tool window" });
|
||||
|
||||
await list.press("ArrowDown");
|
||||
await expect(list.getByRole("option", { name: "Language Servers" })).toHaveAttribute("aria-selected", "true");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(list.getByRole("option", { name: "Version Control", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await versionControlPopup.click();
|
||||
await page.getByRole("option", { name: "No popup", exact: true }).click();
|
||||
await versionControlLog.uncheck();
|
||||
|
||||
await list.press("Home");
|
||||
await expect(systemPopup).toHaveText("Balloon");
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show System Messages in tool window" })).toBeChecked();
|
||||
await list.getByRole("option", { name: "Version Control", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
|
||||
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();
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
});
|
||||
@@ -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" },
|
||||
]);
|
||||
});
|
||||
@@ -0,0 +1,103 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Safe Delete lays out the search option and makes View Usages the default in a narrow window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
await page.setViewportSize({ width: 425, height: 500 });
|
||||
const content = editor.locator(".cm-content");
|
||||
const symbol = "reconcileOutstandingSupplierAdjustmentsForTheMonthlySettlementArchive";
|
||||
const source = [
|
||||
`export function ${symbol}() {`,
|
||||
" return 1;",
|
||||
"}",
|
||||
"",
|
||||
`const debit = ${symbol}();`,
|
||||
`const credit = ${symbol}();`,
|
||||
].join("\n");
|
||||
await content.evaluate(
|
||||
(element, { source, symbol }) => {
|
||||
const view = (element as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: source.indexOf(symbol) + 1 },
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
({ source, symbol }) => {
|
||||
const path = "/dev/acme-api/App.tsx";
|
||||
const range = (line: number, col: number, end = col + symbol.length) => ({
|
||||
start: { line, col },
|
||||
end: { line, col: end },
|
||||
});
|
||||
const selection = range(0, "export function ".length);
|
||||
const handlers = window.__ipc.handlers;
|
||||
handlers.lsp_goto = () => [{ path, range: selection }];
|
||||
handlers.doc_outline = () => [
|
||||
{
|
||||
name: symbol,
|
||||
detail: null,
|
||||
kind: "function",
|
||||
range: { start: { line: 0, col: 0 }, end: { line: 2, col: 1 } },
|
||||
selection_range: selection,
|
||||
children: [],
|
||||
},
|
||||
];
|
||||
handlers.languages = () => [];
|
||||
handlers.lsp_references = () => ({
|
||||
locations: [
|
||||
{ path, range: range(4, "const debit = ".length) },
|
||||
{ path, range: range(5, "const credit = ".length) },
|
||||
],
|
||||
incomplete: null,
|
||||
});
|
||||
handlers.fs_read_text = () => source;
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
const openSafeDelete = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
void executeAction("refactor.safeDelete");
|
||||
});
|
||||
const usageSearches = async () => (await ipcCalls(page, "lsp_references")).filter((call) => call.projectWide);
|
||||
|
||||
await openSafeDelete();
|
||||
const prompt = page.getByRole("dialog", { name: "Safe Delete", exact: true });
|
||||
await expect(prompt.locator("[data-dialog-titlebar]")).toHaveText("Safe Delete");
|
||||
const description = prompt.getByText(`Delete Function '${symbol}'?`);
|
||||
const commentSearch = prompt.getByRole("checkbox", { name: "Search in comments and strings" });
|
||||
await expect(commentSearch).toBeChecked();
|
||||
const expectedLeft = (await description.boundingBox())!.x;
|
||||
expect((await commentSearch.boundingBox())!.x).toBeCloseTo(expectedLeft, 0);
|
||||
await expect(prompt.locator("[data-dialog-body]")).toContainText(symbol);
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(prompt).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
expect(await usageSearches()).toHaveLength(0);
|
||||
|
||||
await openSafeDelete();
|
||||
await commentSearch.uncheck();
|
||||
await prompt.getByRole("button", { name: "OK", exact: true }).click();
|
||||
const conflict = page.getByRole("dialog", { name: "Usages Detected", exact: true });
|
||||
await expect(conflict.getByRole("heading", { name: "2 usages found" })).toBeVisible();
|
||||
await expect(conflict.getByText(`Function '${symbol}' has 2 usages that are not safe to delete.`)).toBeVisible();
|
||||
for (const button of ["View Usages", "Delete Anyway", "Cancel"]) {
|
||||
await expect(conflict.getByRole("button", { name: button, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
expect(
|
||||
await conflict.locator("[data-dialog-body]").evaluate((element) => element.scrollWidth - element.clientWidth),
|
||||
).toBe(0);
|
||||
await expect(conflict.getByRole("button", { name: "View Usages" })).toBeFocused();
|
||||
await page.keyboard.press("Enter");
|
||||
await expect(conflict).toBeHidden();
|
||||
await expect(page.getByRole("region", { name: "Find Usages", exact: true })).toBeVisible();
|
||||
await expect(content).toContainText("export function");
|
||||
expect(await usageSearches()).toHaveLength(1);
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -69,20 +69,53 @@ test("every color scheme page keeps its attribute tree visible", async ({ workbe
|
||||
}
|
||||
});
|
||||
|
||||
for (const id of ["editor.fileTemplates", "editor.liveTemplates"]) {
|
||||
test(`${id} keeps its editor reachable beside the template list`, async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async (id) => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage(id);
|
||||
}, id);
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const editor = page.locator("[class*='split'] > [class*='editor']").first();
|
||||
await expect(editor).toBeAttached();
|
||||
expect((await editor.boundingBox())!.width).toBeGreaterThan(200);
|
||||
test("Live Templates gives the editor the full settings pane width and keeps variable fields reachable", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.liveTemplates");
|
||||
});
|
||||
}
|
||||
const list = dialog.getByRole("listbox", { name: "Live templates" });
|
||||
const body = dialog.getByRole("textbox", { name: "Template text" });
|
||||
await dialog.getByRole("button", { name: "Add Template" }).click();
|
||||
await expect(body).toBeVisible();
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
const bodyBounds = (await body.boundingBox())!;
|
||||
expect(bodyBounds.y).toBeGreaterThan(listBounds.y + listBounds.height);
|
||||
expect(bodyBounds.width).toBeGreaterThan(listBounds.width - 32);
|
||||
|
||||
const handle = dialog.getByRole("separator", { name: "Resize template panes" });
|
||||
await expect(handle).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await handle.press("ArrowDown");
|
||||
await expect.poll(async () => (await list.boundingBox())!.height).toBeGreaterThan(listBounds.height + 10);
|
||||
|
||||
await dialog.getByRole("textbox", { name: "Abbreviation" }).fill("settlement");
|
||||
await dialog.getByRole("textbox", { name: "Filter templates" }).fill("settlement");
|
||||
await expect(list.getByRole("option")).toHaveCount(1);
|
||||
await expect(list.getByRole("option")).toHaveAttribute("aria-selected", "true");
|
||||
await body.fill("record($SETTLEMENT_REFERENCE_IDENTIFIER$, $AMOUNT$)$END$");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 600 });
|
||||
await body.scrollIntoViewIfNeeded();
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
const narrowList = (await list.boundingBox())!;
|
||||
const narrowBody = (await body.boundingBox())!;
|
||||
expect(narrowBody.x + narrowBody.width).toBeLessThanOrEqual(narrowList.x + narrowList.width);
|
||||
const variables = dialog.getByRole("table");
|
||||
const expression = variables.getByRole("textbox", { name: "SETTLEMENT_REFERENCE_IDENTIFIER expression" });
|
||||
await expression.scrollIntoViewIfNeeded();
|
||||
await expect(expression).toBeInViewport({ ratio: 1 });
|
||||
await expression.fill("fileName()");
|
||||
await expect(expression).toHaveValue("fileName()");
|
||||
await expect(
|
||||
variables.getByRole("checkbox", { name: "Skip SETTLEMENT_REFERENCE_IDENTIFIER if defined" }),
|
||||
).toBeVisible();
|
||||
expect(await variables.evaluate((element) => element.scrollWidth - element.clientWidth)).toBe(0);
|
||||
});
|
||||
|
||||
test("Project Structure keeps every details pane usable in a compact window", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+;");
|
||||
|
||||
@@ -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");
|
||||
});
|
||||
@@ -0,0 +1,74 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("Surround With keeps its title and keyboard-selected actions visible in a short window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 680, height: 320 });
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
const source = [
|
||||
"const fee = 5;",
|
||||
"",
|
||||
"function settle(amount: number) {",
|
||||
" const adjusted = amount - fee;",
|
||||
" const receipt = adjusted.toString();",
|
||||
" console.log(receipt);",
|
||||
" return adjusted;",
|
||||
"}",
|
||||
].join("\n");
|
||||
const selectedText = " console.log(receipt);";
|
||||
await content.evaluate(
|
||||
(node, { source, selectedText }) => {
|
||||
const view = (node as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
const start = source.indexOf(selectedText);
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: start, head: start + selectedText.length },
|
||||
scrollIntoView: true,
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, selectedText },
|
||||
);
|
||||
const openSurround = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
await executeAction("code.surroundWith");
|
||||
});
|
||||
|
||||
await openSurround();
|
||||
const popup = page.getByRole("dialog", { name: "Surround With", exact: true });
|
||||
const title = popup.getByText("Surround With", { exact: true });
|
||||
const list = popup.getByRole("listbox");
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => list.evaluate((node) => node.scrollHeight - node.clientHeight)).toBeGreaterThan(0);
|
||||
await expect.poll(() => popup.evaluate((node) => node.scrollHeight - node.clientHeight)).toBe(0);
|
||||
|
||||
const first = list.getByRole("option", { name: /^1\.?\s+if$/ });
|
||||
await expect(first).toHaveAttribute("aria-selected", "true");
|
||||
const action = first.getByText("if", { exact: true });
|
||||
const mnemonic = first.getByText(/^1\.?$/, { exact: true });
|
||||
expect((await mnemonic.boundingBox())!.x + (await mnemonic.boundingBox())!.width).toBeLessThan(
|
||||
(await action.boundingBox())!.x,
|
||||
);
|
||||
expect(await action.evaluate((node) => getComputedStyle(node).fontSize)).toBe("13px");
|
||||
await page.keyboard.press("End");
|
||||
const last = list.getByRole("option", { name: /!\(expr\)/ });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
|
||||
await openSurround();
|
||||
await expect(first).toBeVisible();
|
||||
await page.keyboard.press("1");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toContainText(/if \([^)]*\) \{/);
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
});
|
||||
@@ -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"
|
||||
|
||||
@@ -4,9 +4,15 @@
|
||||
//! renderer, so that is done before the first web view is created. Turning the DMA-BUF
|
||||
//! renderer off also avoids it, but then WebKit paints on the CPU and a tool window drag
|
||||
//! stalls the UI for seconds; setting `WEBKIT_DISABLE_DMABUF_RENDERER=1` still does that.
|
||||
//!
|
||||
//! On Wayland, GTK's default input method goes through the compositor (text-input-v3).
|
||||
//! With IBus behind it, a dead key waiting for its second key makes WebKit collapse every
|
||||
//! new selection in the window to its caret (Select All, mouse drags, text fields) until a
|
||||
//! composition completes. GTK's own IBus module does not, so IBus sessions use that.
|
||||
|
||||
const DISABLE_DMABUF: &str = "WEBKIT_DISABLE_DMABUF_RENDERER";
|
||||
const DISABLE_EXPLICIT_SYNC: &str = "__NV_DISABLE_EXPLICIT_SYNC";
|
||||
const IM_MODULE: &str = "GTK_IM_MODULE";
|
||||
|
||||
/// Run before other threads start (`set_var`).
|
||||
#[cfg(target_os = "linux")]
|
||||
@@ -16,6 +22,35 @@ pub fn configure() {
|
||||
tracing::info!("Wayland with the NVIDIA driver: {DISABLE_EXPLICIT_SYNC}=1");
|
||||
unsafe { std::env::set_var(DISABLE_EXPLICIT_SYNC, "1") };
|
||||
}
|
||||
if use_ibus_module(|k| std::env::var(k).ok(), gtk_ibus_module_installed) {
|
||||
tracing::info!("Wayland with IBus: {IM_MODULE}=ibus");
|
||||
unsafe { std::env::set_var(IM_MODULE, "ibus") };
|
||||
}
|
||||
}
|
||||
|
||||
/// GTK 3's IBus input method module (`ibus-gtk3`), wherever the distribution keeps it.
|
||||
#[cfg(target_os = "linux")]
|
||||
fn gtk_ibus_module_installed() -> bool {
|
||||
const MODULE: &str = "gtk-3.0/3.0.0/immodules/im-ibus.so";
|
||||
let lib_dirs = ["/usr/lib", "/usr/lib64", "/usr/local/lib"];
|
||||
lib_dirs.iter().any(|dir| {
|
||||
let dir = std::path::Path::new(dir);
|
||||
dir.join(MODULE).exists()
|
||||
|| std::fs::read_dir(dir)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.any(|multiarch| multiarch.path().join(MODULE).exists())
|
||||
})
|
||||
}
|
||||
|
||||
/// A Wayland session whose input method is IBus, unless the user chose a GTK module.
|
||||
fn use_ibus_module(var: impl Fn(&str) -> Option<String>, module_installed: impl FnOnce() -> bool) -> bool {
|
||||
if var(IM_MODULE).is_some_and(|v| !v.is_empty()) || !gdk_wayland(&var) {
|
||||
return false;
|
||||
}
|
||||
let ibus = var("XMODIFIERS").is_some_and(|v| v.split_whitespace().any(|m| m == "@im=ibus"));
|
||||
ibus && module_installed()
|
||||
}
|
||||
|
||||
/// Applies Appearance › Smooth scrolling to every new web view
|
||||
@@ -46,11 +81,15 @@ fn disable_explicit_sync(var: impl Fn(&str) -> Option<String>, nvidia: bool) ->
|
||||
if !nvidia || var(DISABLE_DMABUF).is_some() || var(DISABLE_EXPLICIT_SYNC).is_some() {
|
||||
return false;
|
||||
}
|
||||
gdk_wayland(&var)
|
||||
}
|
||||
|
||||
/// GDK will open a Wayland display (it tries the backends of `GDK_BACKEND` in order).
|
||||
fn gdk_wayland(var: &impl Fn(&str) -> Option<String>) -> bool {
|
||||
let wayland_display = var("WAYLAND_DISPLAY").is_some_and(|v| !v.is_empty());
|
||||
// GDK tries the backends of `GDK_BACKEND` in order.
|
||||
let gdk_wayland =
|
||||
let backend =
|
||||
var("GDK_BACKEND").is_none_or(|b| matches!(b.split(',').next().map(str::trim), Some("wayland" | "*" | "")));
|
||||
wayland_display && gdk_wayland
|
||||
wayland_display && backend
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -76,4 +115,26 @@ mod tests {
|
||||
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_DMABUF, "1")], true));
|
||||
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_EXPLICIT_SYNC, "0")], true));
|
||||
}
|
||||
|
||||
fn decide_im(vars: &[(&str, &str)], installed: bool) -> bool {
|
||||
use_ibus_module(|k| vars.iter().find(|(name, _)| *name == k).map(|(_, v)| v.to_string()), || installed)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uses_the_ibus_module_on_wayland_with_ibus_only() {
|
||||
let gnome = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus")];
|
||||
assert!(decide_im(&gnome, true));
|
||||
assert!(decide_im(&[gnome[0], gnome[1], (IM_MODULE, "")], true));
|
||||
assert!(!decide_im(&gnome, false));
|
||||
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=fcitx")], true));
|
||||
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0")], true));
|
||||
assert!(!decide_im(&[("DISPLAY", ":0"), ("XMODIFIERS", "@im=ibus")], true));
|
||||
assert!(!decide_im(&[gnome[0], gnome[1], ("GDK_BACKEND", "x11")], true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_the_users_input_method_module() {
|
||||
let vars = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus"), (IM_MODULE, "wayland")];
|
||||
assert!(!decide_im(&vars, true));
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
+36
-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 })),
|
||||
@@ -3848,6 +3849,8 @@ export type Commit_Deserialize = {
|
||||
historyPath?: string | null,
|
||||
logPosition?: number | null,
|
||||
logTotal?: number | null,
|
||||
/** Newest committer time at or after this row if newer than the row's commit. */
|
||||
logMergeTimeMs?: number | null,
|
||||
graphBoundaryParents?: string[],
|
||||
/** Reachability from HEAD, computed independently of the visible filters. */
|
||||
onCurrentBranch?: boolean | null,
|
||||
@@ -3877,6 +3880,8 @@ export type Commit_Serialize = {
|
||||
historyPath?: string | null,
|
||||
logPosition?: number | null,
|
||||
logTotal?: number | null,
|
||||
/** Newest committer time at or after this row if newer than the row's commit. */
|
||||
logMergeTimeMs?: number | null,
|
||||
graphBoundaryParents?: string[],
|
||||
/** Reachability from HEAD, computed independently of the visible filters. */
|
||||
onCurrentBranch?: boolean | null,
|
||||
@@ -6306,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,
|
||||
@@ -12376,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. */
|
||||
@@ -12424,6 +12453,8 @@ export type VcsRoot = {
|
||||
export type VcsSettings = {
|
||||
/** Colour folders that contain changed files (project tree, tabs). */
|
||||
showDirtyDirectories?: boolean,
|
||||
/** Diffs the user opens show in an editor tab; off, in a separate window. */
|
||||
diffAsEditorTab?: boolean,
|
||||
/** Stop file history (Show History) after `history_limit` commits. */
|
||||
limitHistory?: boolean,
|
||||
historyLimit?: number,
|
||||
|
||||
@@ -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 };
|
||||
}
|
||||
@@ -28,6 +28,7 @@ import {
|
||||
import {
|
||||
acceptCompletion,
|
||||
closeCompletion,
|
||||
completionStatus,
|
||||
currentCompletions,
|
||||
snippet,
|
||||
startCompletion,
|
||||
@@ -840,6 +841,38 @@ describe("completion footer", () => {
|
||||
view = null;
|
||||
});
|
||||
|
||||
it("formats partial results while the language server is still answering", async () => {
|
||||
let finishReply = () => {};
|
||||
const reply = new Promise((resolve) => {
|
||||
finishReply = () => resolve({ isIncomplete: false, items: [] });
|
||||
});
|
||||
setInvokeRoute((cmd) => (cmd === "lsp_completion" ? reply : Promise.resolve(null)));
|
||||
const source: CompletionSource = (ctx) => ({ from: ctx.pos, options: [{ label: "localSuggestion" }] });
|
||||
view = new EditorView({
|
||||
state: EditorState.create({
|
||||
doc: "thing.",
|
||||
selection: { anchor: 6 },
|
||||
extensions: [
|
||||
lspDoc.of({ doc: 902, path: "/p/Example.java", language: "java", uiMode: "Java", readOnly: false }),
|
||||
completionExtension(),
|
||||
EditorState.languageData.of(() => [{ openideaCompletion: source }]),
|
||||
],
|
||||
}),
|
||||
parent: document.body,
|
||||
});
|
||||
try {
|
||||
startCompletion(view);
|
||||
await vi.waitFor(() => {
|
||||
expect(completionStatus(view!.state)).toBe("pending");
|
||||
expect(document.querySelector(".cm-tooltip-autocomplete > .cm-lsp-completion-footer")).not.toBeNull();
|
||||
});
|
||||
} finally {
|
||||
closeCompletion(view);
|
||||
setInvokeRoute(null);
|
||||
finishReply();
|
||||
}
|
||||
});
|
||||
|
||||
it("stays below the list after CodeMirror rebuilds the options", async () => {
|
||||
const source: CompletionSource = (ctx) => ({
|
||||
from: ctx.pos,
|
||||
|
||||
@@ -25,7 +25,16 @@ import {
|
||||
type CompletionSource,
|
||||
} from "@codemirror/autocomplete";
|
||||
import { EditorSelection, EditorState, Prec, StateEffect, StateField, type Text } from "@codemirror/state";
|
||||
import { EditorView, ViewPlugin, getTooltip, keymap, showTooltip, type Rect, type ViewUpdate } from "@codemirror/view";
|
||||
import {
|
||||
EditorView,
|
||||
ViewPlugin,
|
||||
getTooltip,
|
||||
keymap,
|
||||
repositionTooltips,
|
||||
showTooltip,
|
||||
type Rect,
|
||||
type ViewUpdate,
|
||||
} from "@codemirror/view";
|
||||
import {
|
||||
call,
|
||||
commands,
|
||||
@@ -989,7 +998,14 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
class {
|
||||
constructor(private view: EditorView) {}
|
||||
update(u: ViewUpdate) {
|
||||
if (completionStatus(u.state) !== "active") return;
|
||||
// The lookup can show partial results while another source is still pending.
|
||||
const popup = u.state
|
||||
.facet(showTooltip)
|
||||
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
|
||||
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
|
||||
if (!popup) return;
|
||||
popup.offset ??= { x: -completionLabelOffset, y: 0 };
|
||||
const t = popup.dom;
|
||||
this.view.requestMeasure({
|
||||
key: this,
|
||||
read: () => {
|
||||
@@ -1000,19 +1016,12 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
};
|
||||
},
|
||||
write: ({ width, fontSize }) => {
|
||||
const popup = this.view.state
|
||||
.facet(showTooltip)
|
||||
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
|
||||
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
|
||||
if (!popup) return;
|
||||
// Apply the label alignment inside CodeMirror's viewport clamp.
|
||||
popup.offset = { x: -completionLabelOffset, y: 0 };
|
||||
const t = popup.dom;
|
||||
if (t.style.getPropertyValue("--cm-completion-max-width") !== width)
|
||||
t.style.setProperty("--cm-completion-max-width", width);
|
||||
if (!t.isConnected) return;
|
||||
const widthChanged = t.style.getPropertyValue("--cm-completion-max-width") !== width;
|
||||
if (widthChanged) t.style.setProperty("--cm-completion-max-width", width);
|
||||
// The body-level tooltip does not inherit the editor's temporary font zoom.
|
||||
if (t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize)
|
||||
t.style.setProperty("--openidea-editor-font-size", fontSize);
|
||||
const fontChanged = t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize;
|
||||
if (fontChanged) t.style.setProperty("--openidea-editor-font-size", fontSize);
|
||||
let footer = t.querySelector<HTMLElement>(":scope > .cm-lsp-completion-footer");
|
||||
if (!footer) {
|
||||
footer = document.createElement("div");
|
||||
@@ -1023,7 +1032,10 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
}
|
||||
// CodeMirror appends a fresh list when the candidates change.
|
||||
const list = t.querySelector(":scope > ul");
|
||||
if (list && list.nextElementSibling !== footer) list.after(footer);
|
||||
const footerMoved = list && list.nextElementSibling !== footer;
|
||||
if (footerMoved) list.after(footer);
|
||||
// CodeMirror has already measured the lookup. Reposition it before this frame paints.
|
||||
if (widthChanged || fontChanged || footerMoved) repositionTooltips(this.view);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@@ -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": {
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
.summary {
|
||||
display: grid;
|
||||
gap: var(--space-2);
|
||||
}
|
||||
.title {
|
||||
margin: 0;
|
||||
font-size: inherit;
|
||||
font-weight: 600;
|
||||
}
|
||||
.detail {
|
||||
margin: 0;
|
||||
padding: var(--space-3);
|
||||
border: 1px solid var(--border);
|
||||
border-radius: var(--radius-control);
|
||||
color: var(--fg-secondary);
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
import type { Location } from "@/bindings";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { ask } from "@/workbench/messages";
|
||||
import styles from "./SafeDeleteUsages.module.css";
|
||||
|
||||
type UsagesAnswer = "view" | "delete" | "cancel";
|
||||
|
||||
/** `subject`: "Function 'foo'", "File 'a.ts'", "3 files" (`plural`). */
|
||||
export function usagesMessage(
|
||||
subject: string,
|
||||
usages: readonly Location[],
|
||||
plural = false,
|
||||
): { message: string; detail: string } {
|
||||
const n = usages.length;
|
||||
const files = new Set(usages.map((u) => u.path)).size;
|
||||
const where = files > 1 ? tx` (in ${files} files)` : "";
|
||||
let detail: string;
|
||||
if (plural)
|
||||
detail =
|
||||
n === 1
|
||||
? tx`${subject} have ${n} usage that is not safe to delete${where}.`
|
||||
: tx`${subject} have ${n} usages that are not safe to delete${where}.`;
|
||||
else
|
||||
detail =
|
||||
n === 1
|
||||
? tx`${subject} has ${n} usage that is not safe to delete${where}.`
|
||||
: tx`${subject} has ${n} usages that are not safe to delete${where}.`;
|
||||
return { message: n === 1 ? tx`${n} usage found` : tx`${n} usages found`, detail };
|
||||
}
|
||||
|
||||
export async function askUsagesDetected(
|
||||
subject: string,
|
||||
usages: readonly Location[],
|
||||
plural = false,
|
||||
): Promise<UsagesAnswer> {
|
||||
const { message, detail } = usagesMessage(subject, usages, plural);
|
||||
const { button } = await ask({
|
||||
title: "Usages Detected",
|
||||
presentation: "form",
|
||||
width: 540,
|
||||
body: (
|
||||
<div className={styles.summary}>
|
||||
<h2 className={styles.title}>{message}</h2>
|
||||
<p className={styles.detail}>{detail}</p>
|
||||
</div>
|
||||
),
|
||||
buttons: [
|
||||
{ id: "view", label: "View Usages", primary: true },
|
||||
{ id: "delete", label: "Delete Anyway" },
|
||||
],
|
||||
});
|
||||
return button === "view" || button === "delete" ? button : "cancel";
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
export { refactorThis, runRefactoring, showNothingHere } from "./refactorThis";
|
||||
export { askUsagesDetected, fileUsages, safeDelete, viewUsages } from "./safeDelete";
|
||||
export { fileUsages, safeDelete, viewUsages } from "./safeDelete";
|
||||
export { askUsagesDetected } from "./SafeDeleteUsages";
|
||||
export { startHierarchyRefactoring } from "./hierarchy";
|
||||
export { ChangeSignatureDialog } from "./ChangeSignatureDialog";
|
||||
export { JAVA_REFACTORING_COMMAND, runJavaRefactoringCommand } from "./javaMove";
|
||||
|
||||
@@ -2,7 +2,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { EditorState, Text } from "@codemirror/state";
|
||||
import { EditorView } from "@codemirror/view";
|
||||
import { history, undo } from "@codemirror/commands";
|
||||
import type { MessageRequest } from "@/workbench/messages";
|
||||
import { render } from "@testing-library/react";
|
||||
import type { ConfirmOptions, MessageRequest } from "@/workbench/messages";
|
||||
import type { LocalSymbol, Location, Locals, OutlineItem, Pos, Range, StructuralRanges, SyntaxNode } from "@/bindings";
|
||||
|
||||
// --- backend fakes ---------------------------------------------------------
|
||||
@@ -74,13 +75,12 @@ vi.mock("@tauri-apps/api/core", async (orig) => ({
|
||||
let answer = "cancel";
|
||||
const ask = vi.fn(async (_request: MessageRequest) => ({ button: answer, checked: false }));
|
||||
let confirmAnswer: { checked: boolean } | null = { checked: false };
|
||||
const confirmChecked = vi.fn(
|
||||
async (_opts: { title: string; message: string; checkbox?: string; checked?: boolean }) => confirmAnswer,
|
||||
);
|
||||
const confirmChecked = vi.fn(async (_opts: ConfirmOptions) => confirmAnswer);
|
||||
vi.mock("@/workbench/messages", () => ({ ask, confirmChecked }));
|
||||
|
||||
const { deletionRange, localDeclaration, outlineItemAt, safeDelete, fileUsages, usagesMessage, textOccurrences } =
|
||||
const { deletionRange, localDeclaration, outlineItemAt, safeDelete, fileUsages, textOccurrences } =
|
||||
await import("./safeDelete");
|
||||
const { usagesMessage } = await import("./SafeDeleteUsages");
|
||||
const { closePopup, useLspPopup } = await import("@/editor/lsp/popupStore");
|
||||
const { lspDoc } = await import("@/editor/lsp/lsp");
|
||||
|
||||
@@ -294,7 +294,11 @@ describe("safeDelete in the editor", () => {
|
||||
await safeDelete(v);
|
||||
const request = ask.mock.calls[0]![0];
|
||||
expect(request.title).toBe("Usages Detected");
|
||||
expect(request.body).toBe("1 usage found\nFunction 'used' has 1 usage that is not safe to delete.");
|
||||
expect(request.presentation).toBe("form");
|
||||
const summary = render(request.body);
|
||||
expect(summary.getByRole("heading", { name: "1 usage found" })).toBeInTheDocument();
|
||||
expect(summary.getByText("Function 'used' has 1 usage that is not safe to delete.")).toBeInTheDocument();
|
||||
summary.unmount();
|
||||
expect(request.buttons.map((b) => b.label)).toEqual(["View Usages", "Delete Anyway"]);
|
||||
return v;
|
||||
};
|
||||
@@ -314,6 +318,7 @@ describe("safeDelete in the editor", () => {
|
||||
expect(confirmChecked).toHaveBeenCalledTimes(1);
|
||||
const opts = confirmChecked.mock.calls[0]![0];
|
||||
expect(opts.title).toBe("Safe Delete");
|
||||
expect(opts.presentation).toBe("form");
|
||||
expect(opts.message).toBe("Delete Function 'unused'?");
|
||||
expect(opts.checkbox).toBe("Search in comments and strings");
|
||||
expect(lspReferences).not.toHaveBeenCalled();
|
||||
|
||||
@@ -22,11 +22,12 @@ import { structure } from "@/editor/structure";
|
||||
import { docOf, isUnavailable, lspRequest } from "@/editor/lsp/lsp";
|
||||
import { comparePos, offsetToPos, rangeContains, rangeToOffsets } from "@/editor/lsp/positions";
|
||||
import { showHint } from "@/editor/lsp/hint";
|
||||
import { ask, confirmChecked } from "@/workbench/messages";
|
||||
import { confirmChecked } from "@/workbench/messages";
|
||||
import { openPopup, type PreviewOccurrence } from "@/editor/lsp/popupStore";
|
||||
import { cannotPerform } from "./catalog";
|
||||
import { cancelled, languageName } from "./query";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { askUsagesDetected } from "./SafeDeleteUsages";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Deletion range (pure)
|
||||
@@ -260,53 +261,6 @@ async function findUsages(ctx: EditorDocContext, target: SafeDeleteTarget): Prom
|
||||
return refs.filter((l) => outside(l.path, l.range));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Usages Detected dialog
|
||||
|
||||
export type UsagesAnswer = "view" | "delete" | "cancel";
|
||||
|
||||
/** `subject`: "Function 'foo'", "File 'a.ts'", "3 files" (`plural`). */
|
||||
export function usagesMessage(
|
||||
subject: string,
|
||||
usages: readonly Location[],
|
||||
plural = false,
|
||||
): { message: string; detail: string } {
|
||||
const n = usages.length;
|
||||
const files = new Set(usages.map((u) => u.path)).size;
|
||||
const where = files > 1 ? tx` (in ${files} files)` : "";
|
||||
let detail: string;
|
||||
if (plural)
|
||||
detail =
|
||||
n === 1
|
||||
? tx`${subject} have ${n} usage that is not safe to delete${where}.`
|
||||
: tx`${subject} have ${n} usages that are not safe to delete${where}.`;
|
||||
else
|
||||
detail =
|
||||
n === 1
|
||||
? tx`${subject} has ${n} usage that is not safe to delete${where}.`
|
||||
: tx`${subject} has ${n} usages that are not safe to delete${where}.`;
|
||||
return { message: n === 1 ? tx`${n} usage found` : tx`${n} usages found`, detail };
|
||||
}
|
||||
|
||||
/** IDEA's "Usages Detected" question; resolves "cancel" when dismissed. */
|
||||
export async function askUsagesDetected(
|
||||
subject: string,
|
||||
usages: readonly Location[],
|
||||
plural = false,
|
||||
): Promise<UsagesAnswer> {
|
||||
const { message, detail } = usagesMessage(subject, usages, plural);
|
||||
const { button } = await ask({
|
||||
title: "Usages Detected",
|
||||
icon: "warning",
|
||||
body: `${message}\n${detail}`,
|
||||
buttons: [
|
||||
{ id: "view", label: "View Usages", primary: true },
|
||||
{ id: "delete", label: "Delete Anyway" },
|
||||
],
|
||||
});
|
||||
return button === "view" || button === "delete" ? button : "cancel";
|
||||
}
|
||||
|
||||
/** Opens the Find Usages tool window with `usages` (code-insight's `find.showUsageResults`). */
|
||||
export function viewUsages(symbol: string, usages: readonly Location[]) {
|
||||
void executeAction("find.showUsageResults", { symbol, locations: usages });
|
||||
@@ -456,6 +410,7 @@ export async function safeDelete(view: EditorView): Promise<void> {
|
||||
const confirmed = await confirmChecked({
|
||||
title: "Safe Delete",
|
||||
message: tx`Delete ${target.kind} '${target.name}'?`,
|
||||
presentation: "form",
|
||||
ok: "OK",
|
||||
checkbox: "Search in comments and strings",
|
||||
checked: searchInComments,
|
||||
|
||||
@@ -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])];
|
||||
|
||||
@@ -18,6 +18,8 @@ import { vscodeMacos } from "@/platform/keymaps/vscode-macos";
|
||||
import {
|
||||
addBinding,
|
||||
bindingMatches,
|
||||
parseShortcutQuery,
|
||||
shortcutQueryMatches,
|
||||
findConflicts,
|
||||
isModified,
|
||||
removeBinding,
|
||||
@@ -262,6 +264,56 @@ describe("shortcut search", () => {
|
||||
expect(bindingMatches(["Meta+O"], "Meta+Shift+O")).toBe(false);
|
||||
});
|
||||
|
||||
it("reads typed shortcut text in the search field", () => {
|
||||
const m = (bindings: string[], query: string) => {
|
||||
const parsed = parseShortcutQuery(query);
|
||||
return !!parsed && shortcutQueryMatches(bindings, parsed);
|
||||
};
|
||||
for (const q of [
|
||||
"ctrl+shift+n",
|
||||
"Ctrl+Shift+N",
|
||||
"shift+ctrl+n",
|
||||
"ctrl shift n",
|
||||
"Ctrl + Shift + N",
|
||||
"control+shift+n",
|
||||
])
|
||||
expect(m(["Ctrl+Shift+N"], q)).toBe(true);
|
||||
expect(m(["Ctrl+N"], "ctrl+shift+n")).toBe(false);
|
||||
expect(m(["Ctrl+Shift+N"], "ctrl+n")).toBe(false);
|
||||
// Only modifiers typed so far: every shortcut holding them.
|
||||
expect(m(["Ctrl+Shift+N"], "ctrl")).toBe(true);
|
||||
expect(m(["Ctrl+Shift+N"], "ctrl+shift")).toBe(true);
|
||||
expect(m(["Ctrl+Shift+N"], "ctrl+shift+")).toBe(true);
|
||||
expect(m(["Alt+N"], "ctrl")).toBe(false);
|
||||
expect(m(["Shift+Meta+O"], "⇧⌘O")).toBe(true);
|
||||
expect(m(["Shift+Meta+O"], "cmd+shift+o")).toBe(true);
|
||||
expect(m(["Meta+K Meta+C"], "Meta+K, Meta+C")).toBe(true);
|
||||
expect(m(["Meta+K Meta+C"], "cmd+k")).toBe(true);
|
||||
expect(m(["Meta+K Meta+C"], "cmd+k cmd+x")).toBe(false);
|
||||
expect(m(["Shift Shift"], "shift")).toBe(true);
|
||||
expect(m(["Ctrl+Escape"], "ctrl+esc")).toBe(true);
|
||||
expect(m(["Shift+F6"], "shift+f6")).toBe(true);
|
||||
expect(m(["F5"], "f5")).toBe(true);
|
||||
// Plain words stay name searches.
|
||||
expect(parseShortcutQuery("save")).toBeNull();
|
||||
expect(parseShortcutQuery("go to file")).toBeNull();
|
||||
expect(parseShortcutQuery("")).toBeNull();
|
||||
});
|
||||
|
||||
it("lists actions whose shortcut matches the typed text", () => {
|
||||
const run = () => {};
|
||||
const actions = [
|
||||
{ id: "a.one", title: "Alpha", category: "File", run },
|
||||
{ id: "a.two", title: "Beta", category: "File", run },
|
||||
];
|
||||
const draft = { preset: "intellij-windows", overrides: { "a.one": ["Ctrl+Shift+N"], "a.two": ["Ctrl+N"] } };
|
||||
const keys = (nodes: ReturnType<typeof buildKeymapTree>): string[] =>
|
||||
nodes.flatMap((n) => (n.kind === "group" ? keys(n.children) : [n.key]));
|
||||
expect(keys(buildKeymapTree(actions, draft, "ctrl+shift+n", ""))).toEqual(["a.one"]);
|
||||
expect(keys(buildKeymapTree(actions, draft, "ctrl+n", ""))).toEqual(["a.two"]);
|
||||
expect(keys(buildKeymapTree(actions, draft, "Ctrl", "")).sort()).toEqual(["a.one", "a.two"]);
|
||||
});
|
||||
|
||||
it("filters the keymap tree by name and by shortcut", () => {
|
||||
const run = () => {};
|
||||
const actions = [
|
||||
|
||||
@@ -41,6 +41,8 @@ import {
|
||||
isKeymapAction,
|
||||
keymapName,
|
||||
keymapSearchLabels,
|
||||
parseShortcutQuery,
|
||||
shortcutQueryMatches,
|
||||
removeBinding,
|
||||
removeConflicts,
|
||||
renameKeymap,
|
||||
@@ -122,6 +124,7 @@ export function buildKeymapTree(
|
||||
return parent;
|
||||
};
|
||||
const q = query.toLowerCase();
|
||||
const typedShortcut = query ? parseShortcutQuery(query) : null;
|
||||
for (const action of actions) {
|
||||
const bindings = resolveBindings(draft, action.id);
|
||||
if (!isKeymapAction(action, draft)) continue;
|
||||
@@ -130,7 +133,9 @@ export function buildKeymapTree(
|
||||
hits = wordMatch(action.title, query);
|
||||
if (!hits) {
|
||||
const other =
|
||||
action.id.toLowerCase().includes(q) || (action.keywords ?? []).some((k) => k.toLowerCase().includes(q));
|
||||
action.id.toLowerCase().includes(q) ||
|
||||
(action.keywords ?? []).some((k) => k.toLowerCase().includes(q)) ||
|
||||
(!!typedShortcut && shortcutQueryMatches(bindings, typedShortcut));
|
||||
if (!other) continue;
|
||||
hits = [];
|
||||
}
|
||||
|
||||
@@ -188,6 +188,113 @@ export function bindingMatches(bindings: readonly string[], strokes: string): bo
|
||||
return bindings.some((b) => b === q || b.startsWith(q + " "));
|
||||
}
|
||||
|
||||
const MODIFIER_ALIASES: Record<string, string> = {
|
||||
ctrl: "Ctrl",
|
||||
control: "Ctrl",
|
||||
ctl: "Ctrl",
|
||||
"⌃": "Ctrl",
|
||||
alt: "Alt",
|
||||
option: "Alt",
|
||||
opt: "Alt",
|
||||
"⌥": "Alt",
|
||||
shift: "Shift",
|
||||
"⇧": "Shift",
|
||||
meta: "Meta",
|
||||
cmd: "Meta",
|
||||
command: "Meta",
|
||||
super: "Meta",
|
||||
win: "Meta",
|
||||
"⌘": "Meta",
|
||||
};
|
||||
|
||||
const KEY_ALIASES: Record<string, string> = {
|
||||
esc: "escape",
|
||||
return: "enter",
|
||||
"↵": "enter",
|
||||
del: "delete",
|
||||
ins: "insert",
|
||||
pgup: "pageup",
|
||||
pgdn: "pagedown",
|
||||
"↑": "up",
|
||||
"↓": "down",
|
||||
"←": "left",
|
||||
"→": "right",
|
||||
};
|
||||
|
||||
export interface QueryStroke {
|
||||
mods: Set<string>;
|
||||
key: string | null;
|
||||
}
|
||||
|
||||
const MOD_SYMBOLS_RE = /[⌃⌥⇧⌘]/g;
|
||||
|
||||
/**
|
||||
* A search-field query read as typed shortcut text (`ctrl+shift+n`, `Ctrl+K, Ctrl+I`, `⇧⌘O`,
|
||||
* `ctrl shift`), or null when it does not look like one. Needs a modifier, or a lone F-key.
|
||||
*/
|
||||
export function parseShortcutQuery(query: string): QueryStroke[] | null {
|
||||
const text = query
|
||||
.trim()
|
||||
.replace(MOD_SYMBOLS_RE, (s) => ` ${s}+`)
|
||||
.replace(/\s*\+\s*/g, "+")
|
||||
.replace(/^\++|\++$/g, "");
|
||||
if (!text) return null;
|
||||
const strokes: QueryStroke[] = [];
|
||||
let pending: QueryStroke | null = null;
|
||||
for (const raw of text.split(/[\s,]+/).filter(Boolean)) {
|
||||
const stroke: QueryStroke = pending ?? { mods: new Set(), key: null };
|
||||
for (const token of raw.split("+").filter(Boolean)) {
|
||||
const lower = token.toLowerCase();
|
||||
const mod = MODIFIER_ALIASES[lower];
|
||||
if (mod) stroke.mods.add(mod);
|
||||
else if (stroke.key !== null) return null;
|
||||
else stroke.key = KEY_ALIASES[lower] ?? lower;
|
||||
}
|
||||
// `ctrl shift n` spells one stroke: modifiers alone carry over to the next word.
|
||||
if (stroke.key === null) pending = stroke;
|
||||
else {
|
||||
strokes.push(stroke);
|
||||
pending = null;
|
||||
}
|
||||
}
|
||||
if (pending) strokes.push(pending);
|
||||
const hasModifier = strokes.some((s) => s.mods.size > 0);
|
||||
const fKey = strokes.length === 1 && /^f\d{1,2}$/.test(strokes[0]!.key ?? "");
|
||||
return hasModifier || fKey ? strokes : null;
|
||||
}
|
||||
|
||||
const MODIFIER_NAMES: readonly string[] = ["Ctrl", "Alt", "Shift", "Meta"];
|
||||
|
||||
function bindingStroke(stroke: string): QueryStroke {
|
||||
const parts = stroke.split("+");
|
||||
const last = parts.pop()!;
|
||||
const mods = new Set(parts);
|
||||
// Double-modifier gestures (`Shift Shift`, `Alt Alt+Up`) have strokes made of a bare modifier.
|
||||
if (MODIFIER_NAMES.includes(last)) {
|
||||
mods.add(last);
|
||||
return { mods, key: null };
|
||||
}
|
||||
return { mods, key: last.toLowerCase() };
|
||||
}
|
||||
|
||||
/**
|
||||
* Text-search match on shortcuts: earlier query strokes must equal the binding's; the last one
|
||||
* matches on its key with the same modifiers, or — while only modifiers are typed — on any
|
||||
* stroke holding them all (`ctrl+shift` lists every Ctrl+Shift shortcut).
|
||||
*/
|
||||
export function shortcutQueryMatches(bindings: readonly string[], query: readonly QueryStroke[]): boolean {
|
||||
return bindings.some((binding) => {
|
||||
const strokes = normalizeBinding(binding).split(" ").map(bindingStroke);
|
||||
if (query.length > strokes.length) return false;
|
||||
return query.every((q, i) => {
|
||||
const b = strokes[i]!;
|
||||
const last = i === query.length - 1;
|
||||
if (q.key === null && last) return [...q.mods].every((m) => b.mods.has(m));
|
||||
return q.key === b.key && q.mods.size === b.mods.size && [...q.mods].every((m) => b.mods.has(m));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// User keymaps (gear menu: Duplicate… / Rename… / Restore Defaults / Delete)
|
||||
|
||||
|
||||
@@ -132,29 +132,53 @@
|
||||
accent-color: var(--accent);
|
||||
}
|
||||
|
||||
.table {
|
||||
width: 100%;
|
||||
border-collapse: collapse;
|
||||
.notificationGroups {
|
||||
display: grid;
|
||||
grid-template-columns: minmax(0, 2fr) minmax(0, 3fr);
|
||||
align-items: start;
|
||||
gap: var(--space-4);
|
||||
}
|
||||
.table th {
|
||||
white-space: nowrap;
|
||||
text-align: left;
|
||||
font-weight: normal;
|
||||
color: var(--fg-muted);
|
||||
height: var(--h-list-row);
|
||||
padding: 0 8px;
|
||||
border-bottom: 1px solid var(--border);
|
||||
.notificationList {
|
||||
height: calc(10 * var(--h-list-row) + 2px);
|
||||
min-width: 0;
|
||||
border: 1px solid var(--border-strong);
|
||||
border-radius: var(--radius-small);
|
||||
}
|
||||
.table td {
|
||||
white-space: nowrap;
|
||||
height: 32px;
|
||||
padding: 0 8px;
|
||||
.notificationGroupLabel {
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
.table tbody tr:hover {
|
||||
background: var(--bg-tree-hover);
|
||||
.notificationDetails {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: flex-start;
|
||||
min-width: 0;
|
||||
gap: var(--space-2);
|
||||
}
|
||||
.center {
|
||||
text-align: center;
|
||||
.notificationTitle {
|
||||
margin: 0;
|
||||
color: var(--fg-strong);
|
||||
font-size: var(--fs-ui);
|
||||
font-weight: 600;
|
||||
overflow-wrap: anywhere;
|
||||
}
|
||||
.notificationDetails .notificationPopupRow {
|
||||
grid-template-columns: fit-content(42%) minmax(0, 1fr);
|
||||
align-self: stretch;
|
||||
padding-inline: 0;
|
||||
margin-inline: 0;
|
||||
}
|
||||
.notificationPopupRow label {
|
||||
white-space: normal;
|
||||
}
|
||||
@container settings-content (max-width: 440px) {
|
||||
.notificationGroups {
|
||||
grid-template-columns: minmax(0, 1fr);
|
||||
}
|
||||
.notificationList {
|
||||
height: calc(5 * var(--h-list-row) + 2px);
|
||||
}
|
||||
}
|
||||
|
||||
.iconPacks {
|
||||
|
||||
@@ -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;
|
||||
|
||||
Loaded 100 of 139 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача