дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 09:00:49 +02:00
Порівняти коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
64ee535eb7 | ||
|
|
16cda13915 |
No files matched your search
Створено
@@ -4511,7 +4511,6 @@ dependencies = [
|
||||
name = "ide-http"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"hyper-util",
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
|
||||
@@ -51,7 +51,7 @@ async fn run_once(
|
||||
move || launch.resolve_for_launch_with_copilot_env(&root, strip_ambient)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| e.to_string())??;
|
||||
.map_err(|e| e.to_string())?;
|
||||
let cwd = dunce::canonicalize(&root).unwrap_or(root);
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
|
||||
let client = Dialect::wrap(updates.clone());
|
||||
|
||||
@@ -132,7 +132,6 @@ pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct CopilotBinaryKey {
|
||||
command: String,
|
||||
github_account: Option<String>,
|
||||
modified: Option<std::time::SystemTime>,
|
||||
len: Option<u64>,
|
||||
}
|
||||
@@ -141,7 +140,7 @@ struct Shared {
|
||||
paths: AgentPaths,
|
||||
runtime: tokio::runtime::Handle,
|
||||
connector: Connector,
|
||||
sinks: RwLock<HashMap<String, AgentSink>>,
|
||||
sink: RwLock<Option<AgentSink>>,
|
||||
security: RwLock<Option<SecurityHook>>,
|
||||
new_task_approvals: RwLock<Option<NewTaskApprovalsHook>>,
|
||||
known: Arc<Mutex<HashMap<String, Known>>>,
|
||||
@@ -194,7 +193,6 @@ impl Shared {
|
||||
let metadata = std::fs::metadata(&executable).ok();
|
||||
CopilotBinaryKey {
|
||||
command: executable.to_string_lossy().into_owned(),
|
||||
github_account: provider::copilot_github_account(&spec.env),
|
||||
modified: metadata.as_ref().and_then(|m| m.modified().ok()),
|
||||
len: metadata.as_ref().map(std::fs::Metadata::len),
|
||||
}
|
||||
@@ -213,12 +211,10 @@ impl Shared {
|
||||
}
|
||||
|
||||
fn emit(&self, event: AgentEvent) {
|
||||
let mut sinks: Vec<_> = self.sinks.read().values().cloned().collect();
|
||||
let Some(last) = sinks.pop() else { return };
|
||||
for sink in sinks {
|
||||
sink(event.clone());
|
||||
let sink = self.sink.read().clone();
|
||||
if let Some(sink) = sink {
|
||||
sink(event);
|
||||
}
|
||||
last(event);
|
||||
}
|
||||
|
||||
/// The MCP servers passed to a session, and the names of the ones off for it.
|
||||
@@ -563,7 +559,7 @@ impl AgentManager {
|
||||
paths,
|
||||
runtime,
|
||||
connector,
|
||||
sinks: RwLock::new(HashMap::new()),
|
||||
sink: RwLock::new(None),
|
||||
security: RwLock::new(None),
|
||||
new_task_approvals: RwLock::new(None),
|
||||
known,
|
||||
@@ -606,22 +602,12 @@ impl AgentManager {
|
||||
|
||||
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
|
||||
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
|
||||
self.subscribe_as("", sink)
|
||||
}
|
||||
|
||||
/// Routes events to `sink` too, replacing only the sink `subscriber` (a view of the project) had.
|
||||
pub fn subscribe_as(&self, subscriber: &str, sink: AgentSink) -> Vec<AgentTask> {
|
||||
self.shared.sinks.write().insert(subscriber.to_owned(), sink);
|
||||
*self.shared.sink.write() = Some(sink);
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
|
||||
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
|
||||
tasks
|
||||
}
|
||||
|
||||
/// A closed view releases its sink, never the task or its agent process.
|
||||
pub fn unsubscribe(&self, subscriber: &str) {
|
||||
self.shared.sinks.write().remove(subscriber);
|
||||
}
|
||||
|
||||
/// Sets the callback used to read the active command execution security policy.
|
||||
pub fn set_security_hook(&self, hook: SecurityHook) {
|
||||
*self.shared.security.write() = Some(hook);
|
||||
@@ -1140,16 +1126,6 @@ impl AgentManager {
|
||||
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
|
||||
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let provider = task.state.lock().task.provider.clone();
|
||||
let discovered = self
|
||||
.shared
|
||||
.paths
|
||||
.catalogs
|
||||
.cached(&self.shared, &provider)
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option && o.category.as_deref() == Some("model"))
|
||||
.cloned();
|
||||
let (target, change) = {
|
||||
let mut s = task.state.lock();
|
||||
let busy = s.busy;
|
||||
@@ -1170,19 +1146,17 @@ impl AgentManager {
|
||||
task.emit_task();
|
||||
return Ok(());
|
||||
}
|
||||
let session_target = s.task.config.iter().find(|o| o.id == option).cloned();
|
||||
let recovered_model = session_target.is_none();
|
||||
let target = match session_target {
|
||||
Some(target) => target,
|
||||
None if discovered.is_some() => discovered.unwrap(),
|
||||
None => return Err(IdeError::not_found("no such setting")),
|
||||
};
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if s.pending_model.is_some() && config::is_per_model_option(&target) {
|
||||
return Err(IdeError::invalid("This setting is not available on the selected model"));
|
||||
}
|
||||
if recovered_model {
|
||||
(target, None)
|
||||
} else if !target.values.iter().any(|v| v.value == value) {
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
if target.category.as_deref() != Some("model") {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
@@ -1569,18 +1543,6 @@ impl AgentManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn context_usage(&self, id: &str) -> IdeResult<AgentContextUsage> {
|
||||
let task = self.task(id)?;
|
||||
let live = task.live.lock().clone().ok_or_else(|| IdeError::unavailable("the agent session is offline"))?;
|
||||
if !live.capabilities.context_usage {
|
||||
return Err(IdeError::unavailable("this agent does not report context details"));
|
||||
}
|
||||
live.peer
|
||||
.request("_openidea/context_usage", json!({ "sessionId": live.session }), None)
|
||||
.await
|
||||
.map_err(|error| IdeError::internal(task.describe(error)))
|
||||
}
|
||||
|
||||
/// Stops background task `background` of task `id`.
|
||||
pub async fn stop_background(&self, id: &str, background: &str) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
@@ -2012,7 +1974,7 @@ impl AgentManager {
|
||||
// What arrived after the last save (a subagent's late updates).
|
||||
task.persist();
|
||||
}
|
||||
self.shared.sinks.write().clear();
|
||||
*self.shared.sink.write() = None;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2837,12 +2799,9 @@ impl Task {
|
||||
pending_model: Option<&PendingModel>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let mut spec = tokio::task::spawn_blocking(move || {
|
||||
spec.resolve_for_launch_with_copilot_env(&launch_cwd, provider::prefer_stored_copilot_auth())
|
||||
})
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?
|
||||
.map_err(|e| SessionOpenError { message: e, allow_acp_fallback: false })?;
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
|
||||
@@ -3891,7 +3850,6 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
|
||||
rollback: meta("/openidea/rollback"),
|
||||
steer: steer_method(init).is_some(),
|
||||
background_tasks: meta("/openidea/backgroundTasks"),
|
||||
context_usage: meta("/openidea/contextUsage"),
|
||||
};
|
||||
(capabilities, init.prompt("embeddedContext"))
|
||||
}
|
||||
|
||||
@@ -45,8 +45,6 @@ pub struct AgentCapabilities {
|
||||
pub steer: bool,
|
||||
/// It reports its background tasks and stops them one by one.
|
||||
pub background_tasks: bool,
|
||||
/// The connected agent can report a breakdown of its context window.
|
||||
pub context_usage: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -277,24 +275,6 @@ pub struct AgentUsage {
|
||||
pub cost: Option<Box<AgentCost>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentContextUsage {
|
||||
pub categories: Vec<AgentContextCategory>,
|
||||
pub total_tokens: u32,
|
||||
pub max_tokens: u32,
|
||||
pub model: String,
|
||||
pub is_auto_compact_enabled: Option<bool>,
|
||||
pub auto_compact_threshold: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentContextCategory {
|
||||
pub name: String,
|
||||
pub tokens: u32,
|
||||
pub kind: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentCost {
|
||||
|
||||
@@ -407,7 +407,7 @@ impl Shim {
|
||||
"promptCapabilities": { "image": true, "embeddedContext": true },
|
||||
"sessionCapabilities": { "fork": {} },
|
||||
"mcpCapabilities": { "stdio": true, "http": true, "sse": true },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true, "contextUsage": true } },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
|
||||
},
|
||||
"agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
|
||||
"authMethods": [],
|
||||
@@ -492,11 +492,6 @@ impl Shim {
|
||||
session.steer(params.get("prompt").cloned().unwrap_or_default()).map_err(invalid)?;
|
||||
Ok(json!({}))
|
||||
}
|
||||
"_openidea/context_usage" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let proc = session.st.lock().proc.clone().ok_or_else(|| internal("Claude Code is not running"))?;
|
||||
rt.block_on(proc.control(json!({ "subtype": "get_context_usage" }))).map_err(internal)
|
||||
}
|
||||
"_openidea/stop_task" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let task = params.get("taskId").and_then(Value::as_str).ok_or_else(|| invalid("no taskId"))?;
|
||||
|
||||
@@ -144,8 +144,7 @@ async fn discover_once(spec: ProviderSpec, cwd: PathBuf, strip_ambient: bool) ->
|
||||
move || spec.resolve_for_launch_with_copilot_env(&cwd, strip_ambient)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?
|
||||
.map_err(|e| DiscoverError { message: e, allow_acp_fallback: false })?;
|
||||
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
let cwd = dunce::canonicalize(&cwd).unwrap_or(cwd);
|
||||
let args = headless_args(&launch.args);
|
||||
let peer = Peer::spawn_framed(
|
||||
|
||||
@@ -312,7 +312,7 @@ impl Settings {
|
||||
}
|
||||
|
||||
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
|
||||
/// prepending `"auto"` when direct models are present or Copilot advertises an enabled Auto tier.
|
||||
/// prepending `"auto"` when not already in the list.
|
||||
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
|
||||
let units = parse_price_units(price_units);
|
||||
let raw = list
|
||||
@@ -322,7 +322,7 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
|
||||
.map(Vec::as_slice)
|
||||
.unwrap_or_default();
|
||||
let mut out = Vec::new();
|
||||
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && (!raw.is_empty() || auto_model_available(list)) {
|
||||
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && !raw.is_empty() {
|
||||
out.push(ModelEntry {
|
||||
id: "auto".into(),
|
||||
name: "Auto".into(),
|
||||
@@ -344,18 +344,6 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
|
||||
out
|
||||
}
|
||||
|
||||
fn auto_model_available(list: &Value) -> bool {
|
||||
let Some(auto) = list.get("auto") else { return false };
|
||||
if auto.get("enabled").or_else(|| auto.pointer("/status/enabled")).and_then(Value::as_bool) == Some(false) {
|
||||
return false;
|
||||
}
|
||||
let Some(tiers) = auto.get("tiers").and_then(Value::as_array) else { return auto.is_object() };
|
||||
tiers.is_empty()
|
||||
|| tiers.iter().any(|tier| {
|
||||
tier.get("enabled").or_else(|| tier.pointer("/status/enabled")).and_then(Value::as_bool) != Some(false)
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_model(m: &Value, units: &HashMap<String, PriceUnit>) -> Option<ModelEntry> {
|
||||
let id = str_of(m, "id")?.to_owned();
|
||||
if m.get("model_picker_enabled").and_then(Value::as_bool) == Some(false)
|
||||
|
||||
@@ -110,72 +110,6 @@ fn sample_price_units() -> Value {
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_an_enabled_auto_only_catalog() {
|
||||
let list = json!({
|
||||
"models": [],
|
||||
"auto": {
|
||||
"defaultTier": "balance",
|
||||
"tiers": [
|
||||
{
|
||||
"id": "balance",
|
||||
"displayName": "Standard",
|
||||
"type": "auto",
|
||||
"fusionTier": "standard",
|
||||
"status": { "enabled": true, "pickerVisible": true }
|
||||
},
|
||||
{
|
||||
"id": "hydrafusion",
|
||||
"displayName": "High",
|
||||
"type": "fusion",
|
||||
"fusionTier": "high",
|
||||
"status": {
|
||||
"enabled": false,
|
||||
"pickerVisible": true,
|
||||
"reason": "user_not_eligible"
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "fast",
|
||||
"displayName": "Fast",
|
||||
"type": "auto",
|
||||
"status": { "enabled": true, "pickerVisible": false }
|
||||
}
|
||||
],
|
||||
"providerId": "copilot"
|
||||
},
|
||||
"imageModels": []
|
||||
});
|
||||
|
||||
let catalog = models::parse_catalog(&list, None);
|
||||
assert_eq!(catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(), ["auto"]);
|
||||
assert_eq!(Settings::new(&catalog, &UserDefaults::default()).model, "auto");
|
||||
|
||||
let options =
|
||||
config::parse_options(&models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default())));
|
||||
let model = options.iter().find(|option| option.id == MODEL).unwrap();
|
||||
assert_eq!(model.current.as_deref(), Some("auto"));
|
||||
assert_eq!(model.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["auto"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_an_auto_only_catalog_when_every_tier_is_disabled() {
|
||||
let list = json!({
|
||||
"models": [],
|
||||
"auto": {
|
||||
"defaultTier": "balance",
|
||||
"tiers": [
|
||||
{
|
||||
"id": "balance",
|
||||
"status": { "enabled": false, "pickerVisible": true }
|
||||
}
|
||||
]
|
||||
}
|
||||
});
|
||||
|
||||
assert!(models::parse_catalog(&list, None).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
|
||||
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
|
||||
|
||||
@@ -9,8 +9,6 @@ use serde_json::Value;
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub(crate) const COPILOT_GITHUB_ACCOUNT_ENV: &str = "OPENIDEA_COPILOT_GITHUB_ACCOUNT";
|
||||
|
||||
/// The protocol an agent speaks. Native ones run behind an in-process ACP endpoint
|
||||
/// (`native`), so tasks see every agent as ACP and read features from its capabilities.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
@@ -140,31 +138,15 @@ impl ProviderSpec {
|
||||
/// Resolve once before connecting, so authentication guidance names that same install.
|
||||
pub(crate) fn resolve_for_launch(self, cwd: &Path) -> Self {
|
||||
let strip = prefer_stored_copilot_auth();
|
||||
self.resolve_for_launch_base(cwd, strip)
|
||||
self.resolve_for_launch_with_copilot_env(cwd, strip)
|
||||
}
|
||||
|
||||
pub(crate) fn resolve_for_launch_with_copilot_env(
|
||||
self,
|
||||
cwd: &Path,
|
||||
strip_ambient_tokens: bool,
|
||||
) -> Result<Self, String> {
|
||||
let account = is_copilot_provider(&self.id).then(|| copilot_github_account(&self.env)).flatten();
|
||||
let mut resolved = self.resolve_for_launch_base(cwd, strip_ambient_tokens || account.is_some());
|
||||
if let Some(account) = account {
|
||||
let token = github_token_for_account(&account)?;
|
||||
resolved.env.retain(|(name, _)| !AMBIENT_COPILOT_AUTH_VARS.contains(&name.as_str()));
|
||||
resolved.env.push(("COPILOT_GITHUB_TOKEN".into(), token));
|
||||
}
|
||||
Ok(resolved)
|
||||
}
|
||||
|
||||
fn resolve_for_launch_base(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
|
||||
pub(crate) fn resolve_for_launch_with_copilot_env(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
|
||||
if self.driver != Driver::Acp {
|
||||
self.command = crate::native::newest_install(&self.command);
|
||||
}
|
||||
if is_copilot_provider(&self.id) {
|
||||
self.env = sanitized_copilot_env(&self.env, strip_ambient_tokens);
|
||||
self.env.retain(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
}
|
||||
let program = ide_jsonrpc::resolve_spawn_program(&self.command, &self.env);
|
||||
self.command =
|
||||
@@ -182,50 +164,6 @@ pub(crate) fn is_copilot_provider(id: &str) -> bool {
|
||||
id == "copilot" || id.starts_with("copilot-")
|
||||
}
|
||||
|
||||
pub(crate) fn copilot_github_account(env: &[(String, String)]) -> Option<String> {
|
||||
env.iter()
|
||||
.rev()
|
||||
.find(|(name, _)| name == COPILOT_GITHUB_ACCOUNT_ENV)
|
||||
.map(|(_, value)| value.trim())
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(str::to_owned)
|
||||
}
|
||||
|
||||
fn github_token_for_account(account: &str) -> Result<String, String> {
|
||||
let path = ide_core::process::shell_env()
|
||||
.find(|(name, _)| name == "PATH")
|
||||
.map(|(_, value)| value)
|
||||
.or_else(|| ide_core::process::host_var_os("PATH"));
|
||||
let program = path
|
||||
.as_deref()
|
||||
.and_then(|path| ide_core::process::find_executable("gh", path))
|
||||
.ok_or_else(|| "GitHub CLI (`gh`) is required to select a Copilot GitHub account".to_owned())?;
|
||||
let mut command = std::process::Command::new(program);
|
||||
command.args(["auth", "token", "--hostname", "github.com", "--user", account]).envs(ide_core::process::shell_env());
|
||||
for name in AMBIENT_COPILOT_AUTH_VARS {
|
||||
command.env_remove(name);
|
||||
}
|
||||
let output = command
|
||||
.output()
|
||||
.map_err(|error| format!("Couldn't read GitHub authentication for account {account}: {error}"))?;
|
||||
if !output.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
let detail = stderr.trim();
|
||||
return Err(if detail.is_empty() {
|
||||
format!("GitHub CLI has no authenticated account named {account}")
|
||||
} else {
|
||||
format!("Couldn't use GitHub account {account}: {detail}")
|
||||
});
|
||||
}
|
||||
let token = String::from_utf8(output.stdout)
|
||||
.map_err(|_| format!("GitHub CLI returned a non-text token for account {account}"))?;
|
||||
let token = token.trim();
|
||||
if token.is_empty() {
|
||||
return Err(format!("GitHub CLI returned no token for account {account}"));
|
||||
}
|
||||
Ok(token.to_owned())
|
||||
}
|
||||
|
||||
pub(crate) fn prefer_stored_copilot_auth() -> bool {
|
||||
PREFER_STORED_COPILOT_AUTH.load(std::sync::atomic::Ordering::Acquire)
|
||||
}
|
||||
@@ -401,31 +339,6 @@ pub(crate) fn set_builtin_env(
|
||||
id: &str,
|
||||
env: BTreeMap<String, String>,
|
||||
) -> IdeResult<()> {
|
||||
if id == "copilot" {
|
||||
let file = custom_dir.join("copilot.toml");
|
||||
if file.try_exists()?
|
||||
&& let mut agent = CustomAgent::read_with(&file, id, secrets).map_err(IdeError::invalid)?
|
||||
&& agent.registry.is_some()
|
||||
{
|
||||
let existing = agent.env.clone();
|
||||
let mut existing_launch_env = existing.clone();
|
||||
let mut next_launch_env = env.clone();
|
||||
existing_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
next_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
if existing_launch_env != next_launch_env {
|
||||
return Err(IdeError::invalid(format!("{id} is installed from the ACP Registry")));
|
||||
}
|
||||
match env.get(COPILOT_GITHUB_ACCOUNT_ENV).filter(|value| !value.trim().is_empty()) {
|
||||
Some(account) => {
|
||||
agent.env.insert(COPILOT_GITHUB_ACCOUNT_ENV.into(), account.trim().into());
|
||||
}
|
||||
None => {
|
||||
agent.env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
}
|
||||
}
|
||||
return agent.write(&file).map_err(Into::into);
|
||||
}
|
||||
}
|
||||
update_builtin(custom_dir, secrets, id, |agent, _| agent.env = env)
|
||||
}
|
||||
|
||||
@@ -1042,46 +955,6 @@ mod tests {
|
||||
set_builtin_env(dir.path(), None, "not-a-builtin", env).unwrap_err();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registry_copilot_allows_only_the_github_account_override() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("copilot.toml");
|
||||
CustomAgent {
|
||||
name: Some("GitHub Copilot".into()),
|
||||
driver: Driver::Acp,
|
||||
command: "/tools/copilot".into(),
|
||||
args: vec!["--acp".into()],
|
||||
env: BTreeMap::from([("REGISTRY_SETTING".into(), "kept".into())]),
|
||||
registry: Some(RegistryRef { id: "copilot".into(), version: "1.0.0".into() }),
|
||||
}
|
||||
.write(&file)
|
||||
.unwrap();
|
||||
|
||||
set_builtin_env(
|
||||
dir.path(),
|
||||
None,
|
||||
"copilot",
|
||||
BTreeMap::from([
|
||||
("REGISTRY_SETTING".into(), "kept".into()),
|
||||
(COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()),
|
||||
]),
|
||||
)
|
||||
.unwrap();
|
||||
let spec = load(Some(dir.path()), None).into_iter().find(|spec| spec.id == "copilot").unwrap();
|
||||
assert_eq!(copilot_github_account(&spec.env).as_deref(), Some("dengliu_microsoft"));
|
||||
|
||||
set_builtin_env(dir.path(), None, "copilot", BTreeMap::from([("REGISTRY_SETTING".into(), "changed".into())]))
|
||||
.unwrap_err();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn launch_metadata_never_passes_the_github_account_control_to_copilot() {
|
||||
let mut spec = builtin_spec("copilot").unwrap();
|
||||
spec.env.push((COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()));
|
||||
let resolved = spec.resolve_for_launch(Path::new("."));
|
||||
assert!(resolved.env.iter().all(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn acp_adapters_of_native_agents_are_unlisted_until_customized() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -537,14 +537,6 @@ fn install_entry_with(
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
let github_account = (entry.id == "copilot")
|
||||
.then(|| CustomAgent::read(&file).ok())
|
||||
.flatten()
|
||||
.and_then(|agent| agent.env.get(provider::COPILOT_GITHUB_ACCOUNT_ENV).cloned());
|
||||
let mut env = env;
|
||||
if let Some(account) = github_account {
|
||||
env.insert(provider::COPILOT_GITHUB_ACCOUNT_ENV.into(), account);
|
||||
}
|
||||
let agent = CustomAgent {
|
||||
name: Some(entry.name.clone()),
|
||||
driver: Driver::Acp,
|
||||
|
||||
@@ -452,35 +452,6 @@ fn manager(dir: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
manager_at(dir, &dir.join("models.json"), agent)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn subscribers_do_not_replace_or_close_each_other() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let main = Arc::new(Mutex::new(Vec::new()));
|
||||
let child = Arc::new(Mutex::new(Vec::new()));
|
||||
let subscribe = |window: &str, events: &Arc<Mutex<Vec<AgentEvent>>>| {
|
||||
let events = events.clone();
|
||||
mgr.subscribe_as(window, Arc::new(move |event| events.lock().push(event)));
|
||||
};
|
||||
subscribe("main", &main);
|
||||
subscribe("editor-main-1", &child);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 1);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
// A reloaded webview replaces only its own old channel.
|
||||
let reloaded = Arc::new(Mutex::new(Vec::new()));
|
||||
subscribe("editor-main-1", &reloaded);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 2);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.unsubscribe("editor-main-1");
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 3);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
// These tests speak to FakeAgent, never an installed CLI, including after a provider reload.
|
||||
let agents = dir.join("agents");
|
||||
@@ -2362,56 +2333,6 @@ async fn idle_model_switches_discover_controls_and_no_control_models_without_ano
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn session_without_a_model_option_can_select_from_a_recovered_catalog() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
let spec = mgr.shared.spec("claude-acp").unwrap();
|
||||
let (_, flight) = mgr.shared.paths.catalogs.request(&mgr.shared, spec, true, None);
|
||||
if let Some(mut ready) = flight {
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !*ready.borrow_and_update() {
|
||||
ready.changed().await.unwrap();
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
{
|
||||
let task = mgr.task(&task.id).unwrap();
|
||||
let mut state = task.state.lock();
|
||||
state.task.config.retain(|option| option.category.as_deref() != Some("model"));
|
||||
state.task.model = Some("stale-model".into());
|
||||
}
|
||||
|
||||
mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
let task = mgr.task(&task.id).unwrap();
|
||||
{
|
||||
let state = task.state.lock();
|
||||
assert_eq!(state.task.model.as_deref(), Some("small"));
|
||||
let model = state.task.config.iter().find(|option| option.category.as_deref() == Some("model")).unwrap();
|
||||
assert_eq!(model.current.as_deref(), Some("small"));
|
||||
assert!(model.values.iter().any(|value| value.value == "small"));
|
||||
}
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -82,23 +82,11 @@ pub fn load_linked(
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
) -> BuildModel {
|
||||
load_linked_with_jdk(root, cache_dir, maven_repo, settings, gradle_settings, None)
|
||||
}
|
||||
|
||||
/// [`load_linked`] with the JDK Maven runs on, for JDK-activated Maven profiles.
|
||||
pub fn load_linked_with_jdk(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
maven_jdk_version: Option<u32>,
|
||||
) -> BuildModel {
|
||||
let maven = maven::has_projects(root, settings).then(|| {
|
||||
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
|
||||
let repo = maven_repo.or_else(maven::default_local_repo);
|
||||
let mut m = maven::load_with_linked_jdk(root, repo, &profiles, maven_jdk_version, &settings.linked_projects);
|
||||
let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
|
||||
maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
|
||||
// The user settings' profiles can be chosen too (`-P` applies to them as well).
|
||||
for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -92,12 +92,6 @@ pub enum IdeEvent {
|
||||
/// Text version when this transition occurred, including when it was saved.
|
||||
version: u32,
|
||||
},
|
||||
/// An open document's file changed on disk while the buffer had unsaved changes. The buffer
|
||||
/// keeps them (autosave leaves the file alone); the UI offers to load the disk version.
|
||||
DocDiskConflict {
|
||||
doc: DocId,
|
||||
path: String,
|
||||
},
|
||||
/// A complete workspace edit can be undone as one operation.
|
||||
WorkspaceEditApplied {
|
||||
id: u32,
|
||||
|
||||
@@ -76,8 +76,6 @@ pub struct GitSettings {
|
||||
/// label is plain text and a click on it places the caret as past the line end.
|
||||
pub inline_blame_clickable: bool,
|
||||
pub show_branch_in_project_view: bool,
|
||||
/// Branch operations from the branches popup act on every repository of the project.
|
||||
pub sync_branch_operations: bool,
|
||||
/// Path to the git executable; empty = auto-detect.
|
||||
pub executable: String,
|
||||
/// Default of Update Project: `merge` | `rebase`.
|
||||
@@ -119,7 +117,6 @@ impl Default for GitSettings {
|
||||
inline_blame: false,
|
||||
inline_blame_clickable: true,
|
||||
show_branch_in_project_view: false,
|
||||
sync_branch_operations: true,
|
||||
executable: String::new(),
|
||||
update_method: "merge".into(),
|
||||
auto_update_on_push_rejected: false,
|
||||
@@ -179,8 +176,6 @@ pub struct CommitSettings {
|
||||
pub agent_model: String,
|
||||
/// That model's thinking level for commit messages; empty keeps the agent's.
|
||||
pub agent_effort: String,
|
||||
/// Show the Generate Commit Message with Agent button above the commit message.
|
||||
pub agent_button: bool,
|
||||
}
|
||||
|
||||
impl Default for CommitSettings {
|
||||
@@ -206,7 +201,6 @@ impl Default for CommitSettings {
|
||||
agent: String::new(),
|
||||
agent_model: String::new(),
|
||||
agent_effort: String::new(),
|
||||
agent_button: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -612,16 +606,3 @@ impl Default for AgentSecuritySettings {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn git_settings_without_sync_key_execute_on_all_repositories() {
|
||||
let missing: GitSettings = serde_json::from_str("{}").unwrap();
|
||||
assert!(missing.sync_branch_operations);
|
||||
let off: GitSettings = serde_json::from_str(r#"{"syncBranchOperations":false}"#).unwrap();
|
||||
assert!(!off.sync_branch_operations);
|
||||
}
|
||||
}
|
||||
@@ -749,14 +749,6 @@ impl Pool {
|
||||
}
|
||||
|
||||
/// The keep-alive ping (Oracle needs a FROM clause).
|
||||
/// Keep-alive: one cheap round trip on the session.
|
||||
pub async fn ping(&self) -> IdeResult<()> {
|
||||
match self {
|
||||
Pool::Jdbc(p) => p.ping().await,
|
||||
_ => self.rows(self.ping_sql(), 1).await.map(|_| ()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ping_sql(&self) -> &'static str {
|
||||
match self {
|
||||
Pool::Oracle(_) => "SELECT 1 FROM DUAL",
|
||||
|
||||
@@ -5,7 +5,6 @@ use crate::{DataSource, DbManager, QueryResult, ResultColumn};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
use std::io::{Cursor, Read};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Stdio;
|
||||
@@ -459,44 +458,6 @@ impl JdbcPool {
|
||||
}
|
||||
|
||||
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let result = self.exchange_once(fields, sql, cancel).await;
|
||||
if let Err(e) = &result
|
||||
&& fields.first() != Some(&"open")
|
||||
&& e.kind != ide_core::error::ErrorKind::Cancelled
|
||||
&& !self.is_closed()
|
||||
&& !self.session_valid().await
|
||||
{
|
||||
// The session is gone (a proxy or tunnel dropped the idle TCP connection): close the
|
||||
// pool so the next statement or Connect starts a new one instead of failing forever.
|
||||
self.close().await;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Keep-alive: checks the session (any SQL would be dialect-specific) and closes a dead one.
|
||||
pub(crate) async fn ping(&self) -> IdeResult<()> {
|
||||
if self.session_valid().await {
|
||||
return Ok(());
|
||||
}
|
||||
self.close().await;
|
||||
Err(IdeError::new(ide_core::error::ErrorKind::Io, "JDBC connection was lost"))
|
||||
}
|
||||
|
||||
/// Whether the JDBC session still works, asked after a failed statement.
|
||||
async fn session_valid(&self) -> bool {
|
||||
if self.bridge.lock().await.is_none() {
|
||||
return false;
|
||||
}
|
||||
let cancel = CancellationToken::new();
|
||||
match tokio::time::timeout(Duration::from_secs(10), self.exchange_once(&["valid"], "", &cancel)).await {
|
||||
Ok(Ok(result)) => {
|
||||
result.rows.first().and_then(|row| row.first()).cloned().flatten().as_deref() != Some("false")
|
||||
}
|
||||
Ok(Err(_)) | Err(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
async fn exchange_once(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let mut slot = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
@@ -601,32 +562,14 @@ fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
|
||||
impl DbManager {
|
||||
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
|
||||
let mut tables = vec![];
|
||||
let mut column_count = 0;
|
||||
// Read the schemas the source's Schemas tab picks, like the database tree does. It also
|
||||
// keeps large instances usable: an Oracle server exposes dozens of system schemas, and
|
||||
// dumping the columns of all of them takes minutes, during which the bridge (a single
|
||||
// Java process that runs one command at a time) executes none of the user's statements.
|
||||
let introspection = self.source(id)?.introspection;
|
||||
let schemas: Vec<String> =
|
||||
self.schemas(id).await?.into_iter().filter(|s| introspection.shows_schema(s)).collect();
|
||||
let schemas = self.schemas(id).await?;
|
||||
for schema in &schemas {
|
||||
// Columns of the whole namespace in one call; a driver that refuses it still completes tables.
|
||||
let mut columns = if column_count < crate::MAX_META_ROWS {
|
||||
pool.metadata(&["schemaColumns", schema]).await.map(schema_columns).unwrap_or_else(|e| {
|
||||
tracing::warn!("JDBC columns of {schema}: {}", e.message);
|
||||
HashMap::new()
|
||||
})
|
||||
} else {
|
||||
HashMap::new()
|
||||
};
|
||||
for table in self.tables(id, schema).await? {
|
||||
let columns = columns.remove(&table.name).unwrap_or_default();
|
||||
column_count += columns.len();
|
||||
tables.push(crate::CompletionTable {
|
||||
schema: schema.clone(),
|
||||
name: table.name,
|
||||
kind: table.kind,
|
||||
columns,
|
||||
columns: vec![],
|
||||
});
|
||||
if tables.len() >= crate::MAX_META_ROWS {
|
||||
break;
|
||||
@@ -651,49 +594,10 @@ impl DbManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// The bridge's `schemaColumns` rows (table, name, type, nullable, default) by table.
|
||||
fn schema_columns(rows: Vec<Vec<Option<String>>>) -> HashMap<String, Vec<crate::CompletionColumn>> {
|
||||
let mut by_table: HashMap<String, Vec<crate::CompletionColumn>> = HashMap::new();
|
||||
for row in rows {
|
||||
let mut it = row.into_iter();
|
||||
let (Some(Some(table)), Some(Some(name))) = (it.next(), it.next()) else { continue };
|
||||
let data_type = it.next().flatten().unwrap_or_default();
|
||||
let nullable = it.next().flatten().as_deref() != Some("0");
|
||||
let has_default = it.next().flatten().is_some();
|
||||
by_table.entry(table).or_default().push(crate::CompletionColumn {
|
||||
name,
|
||||
data_type,
|
||||
nullable,
|
||||
primary_key: false,
|
||||
has_default,
|
||||
});
|
||||
}
|
||||
by_table
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn schema_columns_group_by_table() {
|
||||
let row = |t: &str, n: &str, null: &str, def: Option<&str>| {
|
||||
vec![Some(t.into()), Some(n.into()), Some("INT".into()), Some(null.into()), def.map(Into::into)]
|
||||
};
|
||||
let by_table = schema_columns(vec![
|
||||
row("orders", "id", "0", None),
|
||||
row("orders", "note", "1", Some("'none'")),
|
||||
row("items", "sku", "1", None),
|
||||
vec![None, Some("orphan".into())],
|
||||
]);
|
||||
let orders = &by_table["orders"];
|
||||
assert_eq!(orders.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "note"]);
|
||||
assert_eq!((orders[0].nullable, orders[0].has_default), (false, false));
|
||||
assert_eq!((orders[1].nullable, orders[1].has_default), (true, true));
|
||||
assert_eq!(by_table["items"].len(), 1);
|
||||
assert_eq!(by_table.len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn frame_codec_checks_both_16_mib_boundaries() {
|
||||
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
|
||||
|
||||
@@ -379,8 +379,8 @@ pub(crate) fn keep_alive(pool: &Arc<Pool>, every: Duration) {
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let Some(p) = pool.upgrade().filter(|p| !p.is_closed()) else { break };
|
||||
if let Err(e) = p.ping().await {
|
||||
tracing::info!("keep-alive: {}", e.message);
|
||||
if let Err(e) = p.rows(p.ping_sql(), 1).await {
|
||||
tracing::debug!("keep-alive: {}", e.message);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -847,12 +847,12 @@ impl DbManager {
|
||||
}
|
||||
|
||||
pub fn is_connected(&self, id: &str) -> bool {
|
||||
self.pools.lock().get(id).is_some_and(|p| !p.is_closed())
|
||||
self.pools.lock().contains_key(id)
|
||||
}
|
||||
|
||||
/// Connected targets (data source ids, `<id>:<database>`).
|
||||
pub fn connected(&self) -> Vec<String> {
|
||||
self.pools.lock().iter().filter(|(_, p)| !p.is_closed()).map(|(id, _)| id.clone()).collect()
|
||||
self.pools.lock().keys().cloned().collect()
|
||||
}
|
||||
|
||||
/// The pool of target `id`, connecting first if needed.
|
||||
@@ -862,13 +862,8 @@ impl DbManager {
|
||||
if self.tunnels.lock().get(source_id).is_some_and(|t| t.is_closed()) {
|
||||
self.disconnect_source(source_id).await;
|
||||
}
|
||||
let cached = self.pools.lock().get(id).cloned();
|
||||
if let Some(p) = cached {
|
||||
if !p.is_closed() {
|
||||
return Ok(p);
|
||||
}
|
||||
// The connection broke (a custom JDBC session whose TCP connection was dropped): reconnect.
|
||||
self.disconnect(id).await;
|
||||
if let Some(p) = self.pools.lock().get(id) {
|
||||
return Ok(p.clone());
|
||||
}
|
||||
let source = self.source(id)?;
|
||||
let password = self.password(&source).await;
|
||||
@@ -922,7 +917,7 @@ impl DbManager {
|
||||
|
||||
/// Disconnects every database of data source `id`.
|
||||
pub async fn disconnect_source(&self, id: &str) {
|
||||
let targets: Vec<String> = self.pools.lock().keys().filter(|t| split_target(t).0 == id).cloned().collect();
|
||||
let targets: Vec<String> = self.connected().into_iter().filter(|t| split_target(t).0 == id).collect();
|
||||
for t in targets {
|
||||
self.disconnect(&t).await;
|
||||
}
|
||||
|
||||
@@ -124,45 +124,6 @@ impl Default for DbIntrospection {
|
||||
}
|
||||
}
|
||||
|
||||
impl DbIntrospection {
|
||||
/// Whether the tree shows this schema: every one with `all_schemas`, otherwise it has to
|
||||
/// match one of the `schemas` patterns. The completion model uses the same test, so it
|
||||
/// offers exactly the tables the tree lists (and does not read the ones it never shows).
|
||||
pub fn shows_schema(&self, name: &str) -> bool {
|
||||
self.all_schemas
|
||||
|| self.schemas.iter().map(|p| p.trim()).filter(|p| !p.is_empty()).any(|p| schema_matches(p, name))
|
||||
}
|
||||
}
|
||||
|
||||
/// `*` matches any run of characters, `?` a single one; a pattern without wildcards matches the
|
||||
/// name as typed (the dialog fills names from the list the server returned, so case is settled).
|
||||
fn schema_matches(pattern: &str, name: &str) -> bool {
|
||||
if !pattern.contains('*') && !pattern.contains('?') {
|
||||
return pattern == name;
|
||||
}
|
||||
let p: Vec<char> = pattern.chars().collect();
|
||||
let n: Vec<char> = name.chars().collect();
|
||||
let (mut pi, mut ni) = (0, 0);
|
||||
// Position of the last `*` and how much of the name it has already swallowed.
|
||||
let mut star: Option<(usize, usize)> = None;
|
||||
while ni < n.len() {
|
||||
if pi < p.len() && (p[pi] == '?' || p[pi] == n[ni]) {
|
||||
pi += 1;
|
||||
ni += 1;
|
||||
} else if pi < p.len() && p[pi] == '*' {
|
||||
star = Some((pi, ni));
|
||||
pi += 1;
|
||||
} else if let Some((at, taken)) = star {
|
||||
pi = at + 1;
|
||||
ni = taken + 1;
|
||||
star = Some((at, taken + 1));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
p[pi..].iter().all(|&c| c == '*')
|
||||
}
|
||||
|
||||
/// Advanced tab: a driver property. PostgreSQL: run-time parameters (and
|
||||
/// `application_name`); MySQL: session variables (and `charset`, `collation`);
|
||||
/// SQLite: pragmas. See [`crate::conn`].
|
||||
@@ -804,24 +765,4 @@ mod tests {
|
||||
assert_eq!(r.snowflake().auth, DbSnowflakeAuth::Browser);
|
||||
assert_eq!(scheme_driver("snowflake"), Some(DbDriver::Snowflake));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn introspection_shows_only_the_picked_schemas() {
|
||||
let mut i = DbIntrospection::default();
|
||||
assert!(i.shows_schema("SYS"), "the default reads every schema");
|
||||
|
||||
i.all_schemas = false;
|
||||
assert!(!i.shows_schema("SYS"), "nothing picked: the tree lists nothing either");
|
||||
|
||||
i.schemas = vec!["XMCB".into(), " APP_* ".into()];
|
||||
assert!(i.shows_schema("XMCB"));
|
||||
assert!(i.shows_schema("APP_INFO"));
|
||||
assert!(!i.shows_schema("APP"), "`*` needs the text that follows it");
|
||||
assert!(!i.shows_schema("SYS"));
|
||||
assert!(!i.shows_schema("xmcb"), "patterns match the names the server returned");
|
||||
|
||||
i.schemas = vec!["?".into()];
|
||||
assert!(i.shows_schema("A"));
|
||||
assert!(!i.shows_schema("AB"));
|
||||
}
|
||||
}
|
||||
@@ -90,10 +90,7 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
|
||||
assert!(result.has_more);
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
|
||||
assert_eq!(result.columns[1].name, "label");
|
||||
let completion = db.completion("test").await?;
|
||||
assert_eq!(completion.default_schema, "main");
|
||||
let items = completion.tables.iter().find(|t| t.schema == "main" && t.name == "items").expect("items");
|
||||
assert_eq!(items.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "label"]);
|
||||
assert_eq!(db.completion("test").await?.default_schema, "main");
|
||||
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
|
||||
let stop = CancellationToken::new();
|
||||
let (cancelled, ()) =
|
||||
@@ -216,36 +213,3 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
|
||||
async fn a_lost_session_reconnects_on_the_next_statement() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let db = manager(tmp.path());
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "fixture".into(),
|
||||
name: "Fixture".into(),
|
||||
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
|
||||
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
|
||||
url_template: String::new(),
|
||||
})?;
|
||||
let source = DataSource {
|
||||
id: "test".into(),
|
||||
name: "Fixture".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
global: true,
|
||||
jdbc_driver: "fixture".into(),
|
||||
url: "jdbc:fixture:".into(),
|
||||
..Default::default()
|
||||
};
|
||||
db.save_sources(vec![source]).await?;
|
||||
let cancel = CancellationToken::new();
|
||||
db.execute("test", "first", 1, &cancel).await?;
|
||||
// The fixture's session reports itself invalid after "drop", like a connection a proxy reset.
|
||||
assert!(db.execute("test", "drop", 1, &cancel).await.unwrap_err().message.contains("connection reset"));
|
||||
assert!(!db.is_connected("test"), "a lost session is no longer listed as connected");
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &cancel).await?.affected, Some(1.0));
|
||||
assert!(db.is_connected("test"));
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
@@ -7,10 +7,9 @@
|
||||
|
||||
use crate::{
|
||||
COMPOSE_DIR, COMPOSE_FILES, COMPOSE_PROJECT, COMPOSE_SERVICE, ContainerOp, DockerAvailability, DockerContainer,
|
||||
DockerEndpoint, DockerImage, DockerImageLayer, DockerLogLine, DockerNetwork, DockerObject, DockerProcessList,
|
||||
DockerSnapshot, DockerVolume, split_csv,
|
||||
DockerEndpoint, DockerImage, DockerNetwork, DockerObject, DockerSnapshot, DockerVolume, split_csv,
|
||||
};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde::Deserialize;
|
||||
use std::collections::BTreeMap;
|
||||
use std::io::{Read, Write};
|
||||
@@ -194,15 +193,9 @@ fn request(addr: &Address, method: &str, path: &str, timeout: Duration) -> IdeRe
|
||||
read_response(&mut conn)
|
||||
}
|
||||
|
||||
/// A response's status line and body framing.
|
||||
struct Head {
|
||||
status: u16,
|
||||
chunked: bool,
|
||||
length: Option<usize>,
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response head until `\r\n\r\n`.
|
||||
fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
|
||||
/// Reads an HTTP/1.1 response: head until `\r\n\r\n`, then the body per its
|
||||
/// framing (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
let mut head: Vec<u8> = Vec::new();
|
||||
let mut byte = [0u8; 1];
|
||||
loop {
|
||||
@@ -235,27 +228,16 @@ fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
|
||||
length = value.parse().ok();
|
||||
}
|
||||
}
|
||||
Ok(Head { status, chunked, length })
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response: its head, then the body per its framing
|
||||
/// (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
let head = read_head(stream)?;
|
||||
let body = read_body(stream, &head)?;
|
||||
Ok(Response { status: head.status, body })
|
||||
}
|
||||
|
||||
fn read_body(stream: &mut impl Read, head: &Head) -> IdeResult<Vec<u8>> {
|
||||
Ok(if head.chunked {
|
||||
let body = if chunked {
|
||||
read_chunked(stream)?
|
||||
} else if let Some(n) = head.length {
|
||||
} else if let Some(n) = length {
|
||||
read_exact_n(stream, n)?
|
||||
} else {
|
||||
let mut body = Vec::new();
|
||||
stream.read_to_end(&mut body)?;
|
||||
body
|
||||
})
|
||||
};
|
||||
Ok(Response { status, body })
|
||||
}
|
||||
|
||||
/// Reads one `\n`-terminated line (returned without it).
|
||||
@@ -500,292 +482,6 @@ pub(crate) fn inspect(
|
||||
})())
|
||||
}
|
||||
|
||||
/// The processes running in a container (`docker top`).
|
||||
pub(crate) fn container_top(ep: &DockerEndpoint, id: &str, timeout: Duration) -> Option<IdeResult<DockerProcessList>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/top", path_segment(id)), timeout)?)?;
|
||||
serde_json::from_str::<ApiTop>(&body)
|
||||
.map(|t| DockerProcessList { titles: t.titles, processes: t.processes })
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's process list is not JSON: {e}")))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiTop {
|
||||
titles: Vec<String>,
|
||||
processes: Vec<Vec<String>>,
|
||||
}
|
||||
|
||||
/// An image's layers, newest first (`docker image history`).
|
||||
pub(crate) fn image_history(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
timeout: Duration,
|
||||
) -> Option<IdeResult<Vec<DockerImageLayer>>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/images/{}/history", path_segment(id)), timeout)?)?;
|
||||
let layers = serde_json::from_str::<Vec<ApiLayer>>(&body)
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's image history is not JSON: {e}")))?;
|
||||
Ok(map_layers(layers, unix_now()))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiLayer {
|
||||
id: String,
|
||||
created: i64,
|
||||
created_by: String,
|
||||
size: i64,
|
||||
comment: String,
|
||||
}
|
||||
|
||||
fn map_layers(layers: Vec<ApiLayer>, now: i64) -> Vec<DockerImageLayer> {
|
||||
layers
|
||||
.into_iter()
|
||||
.map(|l| DockerImageLayer {
|
||||
id: l.id,
|
||||
created_by: l.created_by,
|
||||
size: human_size(l.size),
|
||||
created_since: human_duration((now - l.created).max(0)),
|
||||
created_at: unix_utc(l.created),
|
||||
comment: l.comment,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn unix_now() -> i64 {
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// How often a log stream that has nothing to read checks for cancellation.
|
||||
const LOG_POLL: Duration = Duration::from_millis(200);
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerInspect {
|
||||
config: ApiContainerConfig,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerConfig {
|
||||
tty: bool,
|
||||
}
|
||||
|
||||
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
|
||||
/// from `ep`'s daemon until they end or `cancel` fires.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn logs(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
tail: u32,
|
||||
follow: bool,
|
||||
timestamps: bool,
|
||||
timeout: Duration,
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> Option<IdeResult<()>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
// A TTY container's log is one raw stream; otherwise it is framed per stream.
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/json", path_segment(id)), timeout)?)?;
|
||||
let tty = serde_json::from_str::<ApiContainerInspect>(&body).map(|c| c.config.tty).unwrap_or(false);
|
||||
let path = format!(
|
||||
"/containers/{}/logs?stdout=1&stderr=1&tail={tail}&follow={}×tamps={}",
|
||||
path_segment(id),
|
||||
u8::from(follow),
|
||||
u8::from(timestamps),
|
||||
);
|
||||
let mut conn = Conn::connect(&addr, timeout)?;
|
||||
conn.write_all(
|
||||
format!("GET {path} HTTP/1.1\r\nHost: docker\r\nUser-Agent: openidea\r\nConnection: close\r\n\r\n")
|
||||
.as_bytes(),
|
||||
)?;
|
||||
let head = read_head(&mut conn)?;
|
||||
if !(200..300).contains(&head.status) {
|
||||
let body = read_body(&mut conn, &head)?;
|
||||
check(Response { status: head.status, body })?;
|
||||
}
|
||||
conn.set_timeouts(LOG_POLL);
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
let mut buf = [0u8; 8192];
|
||||
while !decoder.done() {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
match conn.read(&mut buf) {
|
||||
Ok(0) => break,
|
||||
Ok(n) => decoder.feed(&buf[..n], &mut |line| on_line(line))?,
|
||||
Err(e)
|
||||
if matches!(
|
||||
e.kind(),
|
||||
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut | std::io::ErrorKind::Interrupted
|
||||
) => {}
|
||||
Err(e) => return Err(e.into()),
|
||||
}
|
||||
}
|
||||
decoder.finish(&mut |line| on_line(line));
|
||||
Ok(())
|
||||
})())
|
||||
}
|
||||
|
||||
/// Turns a log response body, as it arrives, into lines: undoes the chunked
|
||||
/// transfer encoding, then the per-stream frames (8-byte header: stream, 3 zero
|
||||
/// bytes, big-endian length) unless the container has a TTY.
|
||||
struct LogDecoder {
|
||||
body: BodyFraming,
|
||||
tty: bool,
|
||||
header: Vec<u8>,
|
||||
frame_left: usize,
|
||||
frame_stderr: bool,
|
||||
/// Partial lines of stdout and stderr.
|
||||
partial: [Vec<u8>; 2],
|
||||
}
|
||||
|
||||
enum BodyFraming {
|
||||
Chunked { state: ChunkState, line: Vec<u8> },
|
||||
Length(usize),
|
||||
Close,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum ChunkState {
|
||||
Size,
|
||||
Data(usize),
|
||||
DataEnd,
|
||||
Trailer,
|
||||
Done,
|
||||
}
|
||||
|
||||
impl LogDecoder {
|
||||
fn new(head: &Head, tty: bool) -> Self {
|
||||
let body = if head.chunked {
|
||||
BodyFraming::Chunked { state: ChunkState::Size, line: Vec::new() }
|
||||
} else if let Some(n) = head.length {
|
||||
BodyFraming::Length(n)
|
||||
} else {
|
||||
BodyFraming::Close
|
||||
};
|
||||
Self { body, tty, header: Vec::new(), frame_left: 0, frame_stderr: false, partial: [Vec::new(), Vec::new()] }
|
||||
}
|
||||
|
||||
fn done(&self) -> bool {
|
||||
matches!(self.body, BodyFraming::Chunked { state: ChunkState::Done, .. } | BodyFraming::Length(0))
|
||||
}
|
||||
|
||||
fn feed(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) -> IdeResult<()> {
|
||||
let mut payload = Vec::new();
|
||||
match &mut self.body {
|
||||
BodyFraming::Close => payload.extend_from_slice(bytes),
|
||||
BodyFraming::Length(left) => {
|
||||
let take = (*left).min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
*left -= take;
|
||||
}
|
||||
BodyFraming::Chunked { state, line } => {
|
||||
while !bytes.is_empty() {
|
||||
match *state {
|
||||
ChunkState::Done => break,
|
||||
ChunkState::Data(n) => {
|
||||
let take = n.min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
*state = if take == n { ChunkState::DataEnd } else { ChunkState::Data(n - take) };
|
||||
}
|
||||
_ => {
|
||||
let b = bytes[0];
|
||||
bytes = &bytes[1..];
|
||||
if b != b'\n' {
|
||||
if b != b'\r' {
|
||||
line.push(b);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let text = String::from_utf8_lossy(line).into_owned();
|
||||
line.clear();
|
||||
*state = match *state {
|
||||
ChunkState::Size => {
|
||||
let size = text.split(';').next().unwrap_or_default().trim();
|
||||
match usize::from_str_radix(size, 16) {
|
||||
Ok(0) => ChunkState::Trailer,
|
||||
Ok(n) => ChunkState::Data(n),
|
||||
Err(_) => {
|
||||
return Err(IdeError::internal(
|
||||
"the Docker daemon answered with a malformed chunked response",
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
ChunkState::DataEnd => ChunkState::Size,
|
||||
_ if text.is_empty() => ChunkState::Done,
|
||||
other => other,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
self.frames(&payload, emit);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn frames(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
if self.tty {
|
||||
self.lines(false, bytes, emit);
|
||||
return;
|
||||
}
|
||||
while !bytes.is_empty() {
|
||||
if self.frame_left == 0 {
|
||||
let take = (8 - self.header.len()).min(bytes.len());
|
||||
self.header.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
if self.header.len() == 8 {
|
||||
self.frame_stderr = self.header[0] == 2;
|
||||
self.frame_left =
|
||||
u32::from_be_bytes([self.header[4], self.header[5], self.header[6], self.header[7]]) as usize;
|
||||
self.header.clear();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let take = self.frame_left.min(bytes.len());
|
||||
self.lines(self.frame_stderr, &bytes[..take], emit);
|
||||
self.frame_left -= take;
|
||||
bytes = &bytes[take..];
|
||||
}
|
||||
}
|
||||
|
||||
fn lines(&mut self, stderr: bool, bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
for &b in bytes {
|
||||
if b == b'\n' {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
} else {
|
||||
partial.push(b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Emits the last lines that ended without a newline.
|
||||
fn finish(&mut self, emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
for stderr in [false, true] {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
if !partial.is_empty() {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn line_text(bytes: &[u8]) -> String {
|
||||
String::from_utf8_lossy(bytes.strip_suffix(b"\r").unwrap_or(bytes)).into_owned()
|
||||
}
|
||||
|
||||
/// One URL path segment, percent-encoded so an id cannot change the path.
|
||||
fn path_segment(id: &str) -> String {
|
||||
let mut out = String::with_capacity(id.len());
|
||||
@@ -1121,75 +817,6 @@ mod tests {
|
||||
assert!(read_response(&mut &garbage[..]).is_err());
|
||||
}
|
||||
|
||||
/// Feeds `body` one byte at a time, as a slow connection delivers it.
|
||||
fn decode(head: Head, tty: bool, body: &[u8]) -> (Vec<(bool, String)>, bool) {
|
||||
let mut lines = Vec::new();
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
for b in body {
|
||||
decoder.feed(std::slice::from_ref(b), &mut |l| lines.push((l.stderr, l.text))).unwrap();
|
||||
}
|
||||
let done = decoder.done();
|
||||
decoder.finish(&mut |l| lines.push((l.stderr, l.text)));
|
||||
(lines, done)
|
||||
}
|
||||
|
||||
fn frame(stream: u8, text: &str) -> Vec<u8> {
|
||||
let mut f = vec![stream, 0, 0, 0];
|
||||
f.extend((text.len() as u32).to_be_bytes());
|
||||
f.extend(text.as_bytes());
|
||||
f
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn engine_image_history_reads_like_the_cli() {
|
||||
let layers: Vec<ApiLayer> = serde_json::from_str(
|
||||
r#"[{"Id":"sha256:abc","Created":1000,"CreatedBy":"CMD [\"python3\"]","Size":20500,"Comment":"buildkit","Tags":["py:3"]},
|
||||
{"Id":"<missing>","Created":940,"CreatedBy":"RUN x","Size":0,"Comment":""}]"#,
|
||||
)
|
||||
.unwrap();
|
||||
let rows = map_layers(layers, 1000 + 2 * 7 * 86_400);
|
||||
assert_eq!(
|
||||
rows.iter().map(|l| (l.id.as_str(), l.size.as_str(), l.created_since.as_str())).collect::<Vec<_>>(),
|
||||
[("sha256:abc", "20.5kB", "2 weeks ago"), ("<missing>", "0B", "2 weeks ago")]
|
||||
);
|
||||
assert_eq!(rows[0].created_by, "CMD [\"python3\"]");
|
||||
let top: ApiTop = serde_json::from_str(r#"{"Titles":["PID","CMD"],"Processes":[["1","sh"]]}"#).unwrap();
|
||||
assert_eq!(
|
||||
(top.titles, top.processes),
|
||||
(vec!["PID".to_owned(), "CMD".to_owned()], vec![vec!["1".to_owned(), "sh".to_owned()]])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn container_logs_split_into_stream_lines_across_chunks_and_frames() {
|
||||
// Frames split mid-line, a CRLF line, and a stderr line between stdout parts.
|
||||
let mut framed = frame(1, "tick 1\r\ntick");
|
||||
framed.extend(frame(2, "oops\n"));
|
||||
framed.extend(frame(1, " 2\nlast"));
|
||||
let mut chunked = Vec::new();
|
||||
for part in framed.chunks(7) {
|
||||
chunked.extend(format!("{:x}\r\n", part.len()).as_bytes());
|
||||
chunked.extend(part);
|
||||
chunked.extend(b"\r\n");
|
||||
}
|
||||
chunked.extend(b"0\r\n\r\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: true, length: None }, false, &chunked);
|
||||
assert!(done);
|
||||
let expected = [(false, "tick 1"), (true, "oops"), (false, "tick 2"), (false, "last")];
|
||||
assert_eq!(lines, expected.map(|(e, t)| (e, t.to_owned())));
|
||||
|
||||
// A TTY container's log is one raw stream; the body may end with the connection.
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: None }, true, b"a\r\nb\n");
|
||||
assert!(!done);
|
||||
assert_eq!(lines, [(false, "a".to_owned()), (false, "b".to_owned())]);
|
||||
|
||||
// A Content-Length body ends after its length.
|
||||
let body = frame(1, "one\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: Some(body.len()) }, false, &body);
|
||||
assert!(done);
|
||||
assert_eq!(lines, [(false, "one".to_owned())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn daemon_errors_carry_their_message() {
|
||||
let resp = Response { status: 404, body: br#"{"message":"No such container: missing"}"#.to_vec() };
|
||||
|
||||
@@ -287,11 +287,6 @@ fn check_id(id: &str) -> IdeResult<&str> {
|
||||
/// `docker image history --no-trunc --format '{{json .}}'` of one image.
|
||||
pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImageLayer>> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(layers) = engine::image_history(ep, id, QUICK)
|
||||
{
|
||||
return layers;
|
||||
}
|
||||
let out = run(ep, &["image", "history", "--no-trunc", "--format", "{{json .}}", id], QUICK)?;
|
||||
Ok(parse_image_history(&out))
|
||||
}
|
||||
@@ -299,11 +294,6 @@ pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImage
|
||||
/// `docker top <id>` of a running container.
|
||||
pub fn container_top(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerProcessList> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(processes) = engine::container_top(ep, id, QUICK)
|
||||
{
|
||||
return processes;
|
||||
}
|
||||
let out = run(ep, &["top", id], QUICK)?;
|
||||
Ok(parse_container_top(&out))
|
||||
}
|
||||
@@ -326,11 +316,6 @@ pub fn logs(
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> IdeResult<()> {
|
||||
if docker_executable().is_none()
|
||||
&& let Some(streamed) = engine::logs(ep, id, tail, follow, timestamps, QUICK, cancel, on_line)
|
||||
{
|
||||
return streamed;
|
||||
}
|
||||
let tail = tail.to_string();
|
||||
let mut args = vec!["logs", "--tail", &tail];
|
||||
if follow {
|
||||
|
||||
@@ -5,10 +5,10 @@ use crate::Host;
|
||||
use crate::agent_secrets::{AgentSecrets, Kept};
|
||||
use ide_agent::registry::{AgentRegistry, RegistryPaths};
|
||||
use ide_agent::{
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentContextUsage,
|
||||
AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask,
|
||||
CustomAgentInput, ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer,
|
||||
McpServerInput, McpTransport, NewAgentTask,
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
|
||||
AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput,
|
||||
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
|
||||
McpTransport, NewAgentTask,
|
||||
};
|
||||
use ide_command::command;
|
||||
use ide_core::error::ErrorKind;
|
||||
@@ -17,28 +17,12 @@ use ide_tools::InstallEvent;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::{LazyLock, Mutex};
|
||||
|
||||
/// Streams the project's agent events to `subscriber`, one of the project's windows (a remote
|
||||
/// host sees them all as one `window`); returns every task.
|
||||
/// Streams the project's agent events to this window; returns every task.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_subscribe(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
on_event: Channel<AgentEvent>,
|
||||
subscriber: String,
|
||||
) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe_as(
|
||||
&subscriber,
|
||||
std::sync::Arc::new(move |e| {
|
||||
let _ = on_event.send(e);
|
||||
}),
|
||||
))
|
||||
}
|
||||
|
||||
/// Stops the events of a window that closed.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_unsubscribe(host: &Host, window: &str, subscriber: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.unsubscribe(&subscriber);
|
||||
Ok(())
|
||||
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
|
||||
let _ = on_event.send(e);
|
||||
})))
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
@@ -367,13 +351,6 @@ pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: b
|
||||
host.project(window)?.agents.probe(&provider, refresh).await
|
||||
}
|
||||
|
||||
/// Reads the running session's context categories without sending a prompt.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_context_usage(host: &Host, window: &str, task: String) -> IdeResult<AgentContextUsage> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.context_usage(&task).await
|
||||
}
|
||||
|
||||
/// Stops the task's current turn, or with `subagent` only that subagent's work.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
|
||||
@@ -1100,7 +1077,6 @@ ide_command::domain!(
|
||||
agent_archive,
|
||||
agent_base_text,
|
||||
agent_cancel,
|
||||
agent_context_usage,
|
||||
agent_changes,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
@@ -1141,5 +1117,4 @@ ide_command::domain!(
|
||||
agent_subscribe,
|
||||
agent_unarchive,
|
||||
agent_unqueue,
|
||||
agent_unsubscribe,
|
||||
);
|
||||
@@ -8,79 +8,30 @@ use crate::{Host, Project};
|
||||
use ide_command::command;
|
||||
|
||||
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
|
||||
use ide_build::maven::PomGoto;
|
||||
use ide_build::maven::completion::{PomCompletion, PomCompletionOption};
|
||||
use ide_build::maven::{PomGoto, PomManagedDeclaration, PomNavigationOptions};
|
||||
use ide_build::pom_edit::{ArtifactKey, Exclusion};
|
||||
use ide_build::{BuildModel, BuildTool, SyncOptions, SyncProgress};
|
||||
use ide_core::settings::Settings;
|
||||
use ide_core::{DocId, FileEdit, IdeError, IdeEvent, IdeResult, Location, Pos, Range, RequestId, WorkspaceEdit};
|
||||
use std::collections::HashMap;
|
||||
use std::path::Path;
|
||||
use std::sync::{Arc, Mutex, OnceLock};
|
||||
use std::time::{Duration, Instant};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn join_err(e: tokio::task::JoinError) -> IdeError {
|
||||
IdeError::internal(e.to_string())
|
||||
}
|
||||
|
||||
/// POM gutters in several editors refresh together. A very short cache lets those
|
||||
/// requests share one reactor scan without serving a stale module list after edits settle.
|
||||
const MAVEN_MODULE_CACHE_TTL: Duration = Duration::from_millis(250);
|
||||
type MavenModuleCache = HashMap<String, (Instant, Vec<ide_build::maven::ModulePom>)>;
|
||||
static MAVEN_MODULES: OnceLock<Mutex<MavenModuleCache>> = OnceLock::new();
|
||||
|
||||
fn maven_modules(
|
||||
project: &Project,
|
||||
settings: &Settings,
|
||||
options: &PomNavigationOptions,
|
||||
) -> Vec<ide_build::maven::ModulePom> {
|
||||
let key = format!(
|
||||
"{}\0{:?}\0{:?}\0{:?}\0{:?}",
|
||||
project.root.display(),
|
||||
project.build_cache_dir(),
|
||||
settings.languages.java.maven.linked_projects,
|
||||
options.profiles,
|
||||
options.jdk_version
|
||||
);
|
||||
let cache = MAVEN_MODULES.get_or_init(|| Mutex::new(HashMap::new()));
|
||||
if let Some((_at, modules)) = cache.lock().ok().and_then(|mut cache| {
|
||||
let fresh = cache.get(&key).filter(|(at, _)| at.elapsed() < MAVEN_MODULE_CACHE_TTL).cloned();
|
||||
if fresh.is_none() {
|
||||
cache.remove(&key);
|
||||
}
|
||||
fresh
|
||||
}) {
|
||||
return modules;
|
||||
}
|
||||
let model = load(&project.root, &project.build_cache_dir(), settings).maven.unwrap_or_default();
|
||||
let modules = model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
version: p.version,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
if let Ok(mut cache) = cache.lock() {
|
||||
cache.insert(key, (Instant::now(), modules.clone()));
|
||||
}
|
||||
modules
|
||||
}
|
||||
|
||||
/// The build model with the launch settings applied: the JDK (`JAVA_HOME`), and
|
||||
/// the Maven home and options from Settings › Maven.
|
||||
pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
let mut model = ide_build::load_linked_with_jdk(
|
||||
let mut model = ide_build::load_linked(
|
||||
root,
|
||||
cache,
|
||||
ide_sdk::apply::maven_local_repository(root, settings),
|
||||
&settings.languages.java.maven,
|
||||
&settings.languages.java.gradle,
|
||||
ide_sdk::apply::maven_jdk(root, settings, None).map(|jdk| jdk.major),
|
||||
);
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
if let Some(m) = &mut model.maven {
|
||||
let mvn = ide_sdk::apply::maven_command(root, settings);
|
||||
let options = ide_sdk::apply::maven_options(root, settings);
|
||||
@@ -126,23 +77,6 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
model
|
||||
}
|
||||
|
||||
/// POM navigation follows the same profile choices as the last Maven sync and
|
||||
/// resolves JDK-activated profiles with the project's selected Maven runtime.
|
||||
fn pom_navigation_options(project: &Project, settings: &Settings) -> PomNavigationOptions {
|
||||
let mut profiles = settings.languages.java.maven.profiles(&[]);
|
||||
for profile in ide_build::maven_profiles(&project.build_cache_dir()) {
|
||||
if !profiles.contains(&profile) {
|
||||
profiles.push(profile);
|
||||
}
|
||||
}
|
||||
PomNavigationOptions {
|
||||
local_repo: ide_sdk::apply::maven_local_repository(&project.root, settings)
|
||||
.or_else(ide_build::maven::default_local_repo),
|
||||
profiles,
|
||||
jdk_version: ide_sdk::apply::maven_jdk(&project.root, settings, None).map(|jdk| jdk.major),
|
||||
}
|
||||
}
|
||||
|
||||
/// Build and Run use the same selected toolchain and module-local runtime discovery.
|
||||
fn prepare_plan(mut plan: compile::BuildPlan, root: &Path, settings: &Settings) -> compile::BuildPlan {
|
||||
let kind = match plan.system {
|
||||
@@ -613,9 +547,8 @@ pub async fn maven_dependency_declaration(
|
||||
}
|
||||
|
||||
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
|
||||
/// `${property}` at the caret, the parent POM, or the dependency / plugin's own POM
|
||||
/// (a project module first, then the local repository). A dependency without a
|
||||
/// resolvable artifact POM falls back to its management entry.
|
||||
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
|
||||
/// entry providing the dependency's / plugin's version, along the parent chain.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
|
||||
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
|
||||
@@ -628,55 +561,26 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let module_options = options.clone();
|
||||
let modules = || maven_modules(&project, &settings, &module_options);
|
||||
Ok(ide_build::maven::goto_declaration_with(&text, &path, pos, options, modules))
|
||||
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings)
|
||||
.or_else(ide_build::maven::default_local_repo);
|
||||
let modules = || {
|
||||
let model = load(&project.root, &project.build_cache_dir(), &settings).maven.unwrap_or_default();
|
||||
model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
Ok(ide_build::maven::goto_declaration_in(&text, &path, pos, repo, modules))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// Gutter targets of the unversioned dependencies and plugins in a Maven POM:
|
||||
/// the management declarations that actually supply their versions, including
|
||||
/// parent POMs and imported BOMs. Cancel with `cancel_request(request)`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_managed_declarations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
pom: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<PomManagedDeclaration>> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_project_read_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let given = Path::new(&pom);
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let cancelled = cancel.clone();
|
||||
let module_options = options.clone();
|
||||
let modules = || {
|
||||
if cancelled.is_cancelled() {
|
||||
return Vec::new();
|
||||
}
|
||||
maven_modules(&project, &settings, &module_options)
|
||||
};
|
||||
let declarations = ide_build::maven::managed_declarations_with(&text, &path, options, modules);
|
||||
if cancel.is_cancelled() { Err(IdeError::cancelled()) } else { Ok(declarations) }
|
||||
})
|
||||
.await;
|
||||
host.end_request(request);
|
||||
match result {
|
||||
Ok(result) => result,
|
||||
Err(error) => Err(join_err(error)),
|
||||
}
|
||||
}
|
||||
|
||||
/// How long completion waits for Maven Central before answering from the local repository.
|
||||
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
|
||||
|
||||
@@ -1429,5 +1333,4 @@ ide_command::domain!(
|
||||
maven_dependency_declaration,
|
||||
maven_exclude_dependency,
|
||||
maven_goto_declaration,
|
||||
maven_managed_declarations,
|
||||
);
|
||||
@@ -70,13 +70,6 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
/// Load Changes from Disk: discards the buffer's unsaved changes and reads its file again.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_reload_from_disk(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.discard_and_reload(doc)).await
|
||||
}
|
||||
|
||||
/// An automatic save: `false` (nothing written) when the file changed on disk after the
|
||||
/// buffer was edited, which only an explicit save overwrites.
|
||||
#[command(trust = always)]
|
||||
@@ -127,7 +120,6 @@ ide_command::domain!(
|
||||
doc_edit,
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_reload_from_disk,
|
||||
doc_save,
|
||||
doc_autosave,
|
||||
doc_save_all,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::*;
|
||||
use crate::{HostConfig, Project};
|
||||
use ide_core::{IdeEvent, TextChange};
|
||||
use ide_core::{IdeEvent, TextChange, event::NotifyLevel};
|
||||
use parking_lot::Mutex;
|
||||
use std::{path::Path, sync::Arc};
|
||||
|
||||
@@ -57,9 +57,7 @@ impl Fixture {
|
||||
self.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| {
|
||||
matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::DocDiskConflict { .. })
|
||||
})
|
||||
.filter(|e| matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::Notify { .. }))
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
@@ -112,7 +110,7 @@ async fn dirty_document_keeps_edits_and_warns_once() {
|
||||
let loaded = f.project.documents.snapshot(original.id).unwrap();
|
||||
assert_eq!(loaded.text, "local original\n");
|
||||
assert!(loaded.dirty);
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::DocDiskConflict { .. }]));
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::Notify { level: NotifyLevel::Warning, .. }]));
|
||||
f.events.lock().clear();
|
||||
f.sync().await;
|
||||
assert!(f.document_events().is_empty());
|
||||
|
||||
@@ -122,38 +122,28 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
|
||||
|
||||
/// The interpreter the project uses: the configured one, else its virtualenv.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_effective(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
near: Option<PathBuf>,
|
||||
) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let (config_dir, project_root) = (host.config_dir.clone(), project.root.clone());
|
||||
// Loading a member's settings needs more stack than a sync command's main thread has left.
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project_root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project_root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project_root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&host.config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project.root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project.root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project.root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
}
|
||||
|
||||
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
|
||||
@@ -471,7 +461,7 @@ mod tests {
|
||||
host.open_project("main", &root).unwrap();
|
||||
let detected = sdk_detect(&host, "main", SdkKind::Python).await.unwrap();
|
||||
assert!(detected.iter().any(|s| s.path == sdk.path && s.name == sdk.name));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).await.unwrap(), Some(sdk.path));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).unwrap(), Some(sdk.path));
|
||||
assert!(sdk_python_interpreter(&host, "main", root.join("README.md")).await.unwrap().is_none());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
@@ -633,14 +633,8 @@ pub async fn vcs_add_to_ignore(
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
// The Changes view lists every repository of the window (the project's and the
|
||||
// attached ones'): a path inside the project folder, or in any of those repositories.
|
||||
// The folder check stays so a request right after opening, before the repositories
|
||||
// are discovered, still works.
|
||||
let repos = project.repos();
|
||||
for path in &paths {
|
||||
let in_project = path != &project.root && path.starts_with(&project.root);
|
||||
if !in_project && repos.for_path(path).is_none() {
|
||||
if path == &project.root || !path.starts_with(&project.root) {
|
||||
return Err(ide_core::IdeError::invalid("Ignore selection is outside the project"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -191,7 +191,6 @@ pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
|
||||
| IdeEvent::ExcludedDirsChanged { .. }
|
||||
| IdeEvent::DocPatched { .. }
|
||||
| IdeEvent::DocDirty { .. }
|
||||
| IdeEvent::DocDiskConflict { .. }
|
||||
| IdeEvent::WorkspaceEditApplied { .. }
|
||||
| IdeEvent::DocLanguage { .. }
|
||||
| IdeEvent::Diagnostics { .. }
|
||||
|
||||
@@ -161,7 +161,7 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
|
||||
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
|
||||
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).await.is_err());
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
|
||||
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
|
||||
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
|
||||
@@ -351,7 +351,7 @@ async fn python_venv() {
|
||||
// The project's virtualenv: listed first, and the interpreter the project uses.
|
||||
let found = ops::sdk::sdk_detect(&p.host, WINDOW, ide_sdk::SdkKind::Python).await.unwrap();
|
||||
assert_eq!(found.first().map(|s| s.source.as_str()), Some("venv"), "{found:?}");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).await.unwrap().expect("an interpreter");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).unwrap().expect("an interpreter");
|
||||
assert!(effective.starts_with(p.root.join(".venv")), "{effective:?}");
|
||||
}
|
||||
|
||||
|
||||
@@ -21,7 +21,6 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("same.txt"), format!("root {i}\n")).unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
@@ -66,75 +65,3 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new()).await.is_err());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
/// The Changes view also lists attached projects' repositories, and their untracked files
|
||||
/// offer Add to .gitignore / .git/info/exclude: the guard must follow the window's
|
||||
/// repository set, not the project folder alone.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn add_to_ignore_accepts_the_repositories_of_attached_projects() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let project_root = base.join("project");
|
||||
let attached_root = base.join("attached");
|
||||
for root in [&project_root, &attached_root] {
|
||||
std::fs::create_dir_all(root).unwrap();
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("tracked.txt"), "x\n").unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
}
|
||||
// Untracked files, one per repository; the attached one is what failed.
|
||||
let own = project_root.join("own.ignore-me");
|
||||
let attached = attached_root.join("attached.ignore-me");
|
||||
std::fs::write(&own, "x").unwrap();
|
||||
std::fs::write(&attached, "x").unwrap();
|
||||
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&project_root, true, false).unwrap();
|
||||
host.trust.decide(&attached_root, true, false).unwrap();
|
||||
let project = host.open_project("main", &project_root).unwrap();
|
||||
ide_host::ops::project::attach_workspace(&host, "main", &attached_root).unwrap();
|
||||
for _ in 0..500 {
|
||||
if project.repos().all().len() == 2 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(project.repos().all().len(), 2);
|
||||
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![attached.clone()], ide_vcs::IgnoreDestination::Gitignore).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(attached_root.join(".gitignore")).unwrap().contains("/attached.ignore-me"),
|
||||
"the attached repository's .gitignore did not receive the rule"
|
||||
);
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![own.clone()], ide_vcs::IgnoreDestination::LocalExclude).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(project_root.join(".git/info/exclude")).unwrap().contains("/own.ignore-me"),
|
||||
"the project repository's exclude did not receive the rule"
|
||||
);
|
||||
|
||||
// A repository of an unattached sibling folder stays outside.
|
||||
let sibling_root = base.join("sibling");
|
||||
std::fs::create_dir_all(&sibling_root).unwrap();
|
||||
git(&sibling_root, &["init", "-b", "main"]);
|
||||
let sibling = sibling_root.join("sibling.ignore-me");
|
||||
std::fs::write(&sibling, "x").unwrap();
|
||||
let error =
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![sibling], ide_vcs::IgnoreDestination::Gitignore).await.unwrap_err();
|
||||
assert!(error.message.contains("outside the project"), "{error:?}");
|
||||
assert!(!sibling_root.join(".gitignore").exists());
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -199,9 +199,7 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
host.trust.decide(&member, true, false).unwrap();
|
||||
host.open_project("main", &primary).unwrap();
|
||||
let python = |near: Option<&std::path::Path>| {
|
||||
futures::executor::block_on(ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())))
|
||||
.unwrap()
|
||||
.map(|p| p.into_path_buf())
|
||||
ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())).unwrap().map(|p| p.into_path_buf())
|
||||
};
|
||||
// The primary project's own virtualenv, and the bare member inheriting it.
|
||||
assert_eq!(python(Some(&primary)), Some(venv_python.clone()));
|
||||
@@ -219,13 +217,6 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(configured));
|
||||
// A workspace file that fails to load (a corrupt one, say) falls back to the
|
||||
// primary project's interpreter instead of failing the whole command.
|
||||
let workspace_file = primary.join(ide_workspace::workspace::FILE);
|
||||
let valid = std::fs::read(&workspace_file).unwrap();
|
||||
std::fs::write(&workspace_file, b"{not json").unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(venv_python.clone()));
|
||||
std::fs::write(&workspace_file, valid).unwrap();
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
|
||||
@@ -15,8 +15,6 @@ tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
parking_lot.workspace = true
|
||||
reqwest.workspace = true
|
||||
# The system proxy reqwest reads, to notice when it changes (see `client::shared`).
|
||||
hyper-util = { version = "0.1", default-features = false, features = ["client-proxy", "client-proxy-system"] }
|
||||
rustls.workspace = true
|
||||
rustls-platform-verifier.workspace = true
|
||||
uuid.workspace = true
|
||||
|
||||
@@ -5,7 +5,7 @@ use ide_core::proxy_settings::{ProxyMode, ProxyRoute, ProxySettings};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use parking_lot::Mutex;
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
use std::time::Duration;
|
||||
|
||||
/// `builder` routed as `proxy` says: direct, the environment's proxy (reqwest's
|
||||
/// default), or the manual proxy except for the "No proxy for" hosts.
|
||||
@@ -62,61 +62,33 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
|
||||
with_proxy(builder, proxy).build().map_err(|e| fail(e.to_string()))
|
||||
}
|
||||
|
||||
/// A client built for these proxy settings and, in Auto mode, this system proxy.
|
||||
struct Cached {
|
||||
settings: Arc<ProxySettings>,
|
||||
system: Option<String>,
|
||||
client: reqwest::Client,
|
||||
}
|
||||
|
||||
/// The client for the current proxy settings, rebuilt when they change.
|
||||
pub fn shared() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build, system_proxy)
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build)
|
||||
}
|
||||
|
||||
/// The client the HTTP Client executes requests with: redirects off, `exec`
|
||||
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
|
||||
/// 301/302 and puts the redirect chain into the response.
|
||||
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()), system_proxy)
|
||||
}
|
||||
|
||||
/// The system proxy (the environment's, then macOS / Windows settings) as reqwest reads
|
||||
/// it when a client is built, re-read at most every few seconds. A client in Auto mode
|
||||
/// keeps the proxy it was built with, so a proxy app that switches the system proxy on
|
||||
/// after launch would otherwise leave downloads going direct until a restart.
|
||||
fn system_proxy() -> String {
|
||||
static LAST: Mutex<Option<(Instant, String)>> = Mutex::new(None);
|
||||
let mut last = LAST.lock();
|
||||
if let Some((at, seen)) = last.as_ref()
|
||||
&& at.elapsed() < Duration::from_secs(3)
|
||||
{
|
||||
return seen.clone();
|
||||
}
|
||||
// Credentials are left out of the matcher's `Debug`.
|
||||
let seen = format!("{:?}", hyper_util::client::proxy::matcher::Matcher::from_system());
|
||||
*last = Some((Instant::now(), seen.clone()));
|
||||
seen
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()))
|
||||
}
|
||||
|
||||
fn cached_client(
|
||||
slot: &Mutex<Option<Cached>>,
|
||||
build: impl Fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
system: fn() -> String,
|
||||
slot: &Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>>,
|
||||
build: fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
) -> IdeResult<reqwest::Client> {
|
||||
let proxy = ide_core::proxy_settings::proxy();
|
||||
let system = (proxy.mode == ProxyMode::Auto).then(system);
|
||||
let mut cached = slot.lock();
|
||||
if let Some(c) = cached.as_ref()
|
||||
&& *c.settings == *proxy
|
||||
&& c.system == system
|
||||
if let Some((settings, client)) = cached.as_ref()
|
||||
&& **settings == *proxy
|
||||
{
|
||||
return Ok(c.client.clone());
|
||||
return Ok(client.clone());
|
||||
}
|
||||
let client = build(&proxy)?;
|
||||
*cached = Some(Cached { settings: proxy, system, client: client.clone() });
|
||||
*cached = Some((proxy, client.clone()));
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
@@ -170,36 +142,6 @@ pub fn describe(e: &reqwest::Error) -> String {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn auto_mode_rebuilds_the_shared_client_when_the_system_proxy_changes() {
|
||||
static SYSTEM: Mutex<String> = Mutex::new(String::new());
|
||||
static BUILDS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
fn system() -> String {
|
||||
SYSTEM.lock().clone()
|
||||
}
|
||||
let slot = Mutex::new(None);
|
||||
let get = || {
|
||||
cached_client(
|
||||
&slot,
|
||||
|proxy| {
|
||||
BUILDS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
build(proxy)
|
||||
},
|
||||
system,
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
assert_eq!(ide_core::proxy_settings::proxy().mode, ProxyMode::Auto);
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
// A proxy app switches the system proxy on after launch.
|
||||
*SYSTEM.lock() = "Matcher { https: 127.0.0.1:7890 }".into();
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 2);
|
||||
}
|
||||
use ide_core::proxy_settings::ProxyKind;
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::net::TcpListener;
|
||||
|
||||
@@ -265,7 +265,7 @@ impl ProjectIndex {
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let recent = self.shared.recent.lock().clone();
|
||||
let d = self.shared.data.read();
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, Some(&self.root), limit)
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, limit)
|
||||
}
|
||||
|
||||
/// All indexed files with this exact basename, for resolving printed source locations.
|
||||
@@ -301,7 +301,7 @@ impl ProjectIndex {
|
||||
|
||||
/// Fuzzy search for folders that hold indexed files; `rel_path` ends in `/`.
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.shared.data.read(), query, Some(&self.root), limit)
|
||||
matching::find_dirs(&self.shared.data.read(), query, limit)
|
||||
}
|
||||
|
||||
/// Fuzzy symbol search; CamelHump aware (`OCo` → `OrderController`).
|
||||
@@ -574,11 +574,11 @@ pub mod bench_support {
|
||||
}
|
||||
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, None, limit)
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, limit)
|
||||
}
|
||||
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.data, query, None, limit)
|
||||
matching::find_dirs(&self.data, query, limit)
|
||||
}
|
||||
|
||||
pub fn find_symbols(&self, query: &str, filter: SymbolFilter, limit: usize) -> Vec<SymbolMatch> {
|
||||
|
||||
@@ -205,67 +205,29 @@ impl<'a> Recents<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; a pasted absolute path under `root` -> its project-relative
|
||||
/// form; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str, root: Option<&Path>) -> String {
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str) -> String {
|
||||
let mut q = q.trim().replace('\\', "/");
|
||||
// `\\?\C:\a` (verbatim) and `\\.\C:\a` name `C:/a`.
|
||||
if let Some(rest) = verbatim_target(&q) {
|
||||
q = rest.to_owned();
|
||||
}
|
||||
while let Some((head, tail)) = q.rsplit_once(':')
|
||||
&& !tail.is_empty()
|
||||
&& tail.bytes().all(|b| b.is_ascii_digit())
|
||||
{
|
||||
q = head.to_owned();
|
||||
}
|
||||
if let Some(root) = root
|
||||
&& let Some(rel) = strip_root(&q, root)
|
||||
{
|
||||
q = rel;
|
||||
}
|
||||
let q = q.trim_start_matches("./").trim_start_matches('/');
|
||||
q.chars().filter(|c| !c.is_whitespace()).collect()
|
||||
}
|
||||
|
||||
/// Path a `\\?\` / `\\.\` verbatim prefix points at, for a `/`-separated path.
|
||||
fn verbatim_target(q: &str) -> Option<&str> {
|
||||
q.strip_prefix("//?/").or_else(|| q.strip_prefix("//./"))
|
||||
}
|
||||
|
||||
/// `q` (already `/`-separated) below `root`, without the separating slash. A drive-letter root
|
||||
/// compares like Windows, where case does not matter.
|
||||
fn strip_root(q: &str, root: &Path) -> Option<String> {
|
||||
let root = root.to_string_lossy().replace('\\', "/");
|
||||
let root = verbatim_target(&root).unwrap_or(&root);
|
||||
let root = root.trim_end_matches('/');
|
||||
let windows = root.as_bytes().get(1) == Some(&b':');
|
||||
let head = q.get(..root.len())?;
|
||||
if head != root && !(windows && head.eq_ignore_ascii_case(root)) {
|
||||
return None;
|
||||
}
|
||||
match q.get(root.len()..)? {
|
||||
"" => Some(String::new()),
|
||||
tail => tail.strip_prefix('/').map(str::to_owned),
|
||||
}
|
||||
}
|
||||
|
||||
enum FileQuery {
|
||||
Name(Needle),
|
||||
Path { dir: Needle, name: Needle },
|
||||
}
|
||||
|
||||
pub(crate) fn find_files(
|
||||
data: &IndexData,
|
||||
recents: &Recents,
|
||||
query: &str,
|
||||
root: Option<&Path>,
|
||||
limit: usize,
|
||||
) -> Vec<FileMatch> {
|
||||
pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
if limit == 0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let q = normalize_file_query(query, root);
|
||||
let q = normalize_file_query(query);
|
||||
if q.is_empty() {
|
||||
return recents
|
||||
.paths
|
||||
@@ -344,8 +306,8 @@ pub(crate) fn find_files(
|
||||
|
||||
/// Fuzzy folder search over the folders holding indexed files: folder-name matches beat
|
||||
/// path matches; `/` in the query matches the whole path. `rel_path` ends in `/`.
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, root: Option<&Path>, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query, root);
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query);
|
||||
if limit == 0 || q.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
@@ -711,18 +673,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn normalizes_queries() {
|
||||
let root = Path::new("E:/work/sample");
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 ", None), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b", None), "ab");
|
||||
// A pasted absolute path names an indexed file (#4079 follow-up).
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"e:/WORK/sample\pkg/Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"\\?\E:\work\sample\src\App.kt", Some(root)), "src/App.kt");
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go:12:4", Some(root)), "pkg/Config.go");
|
||||
// Outside the project, and a POSIX root, keep the path as given.
|
||||
assert_eq!(normalize_file_query(r"E:\elsewhere\x.go", Some(root)), "E:/elsewhere/x.go");
|
||||
assert_eq!(normalize_file_query("/home/me/Src/a.rs", Some(Path::new("/home/me/src"))), "home/me/Src/a.rs");
|
||||
assert_eq!(normalize_file_query("/home/me/src/a.rs", Some(Path::new("/home/me/src"))), "a.rs");
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 "), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b"), "ab");
|
||||
assert_eq!(split_symbol_query("Order.save"), (Some("Order"), "save"));
|
||||
assert_eq!(split_symbol_query("a::b::C::new"), (Some("C"), "new"));
|
||||
assert_eq!(split_symbol_query("save"), (None, "save"));
|
||||
|
||||
@@ -190,19 +190,6 @@ fn file_ranking_is_idea_like() {
|
||||
assert_eq!(shown.to_lowercase(), "uibtn");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pasted_absolute_path_finds_the_indexed_file() {
|
||||
let fx = sample();
|
||||
let idx = fx.open();
|
||||
let abs = fx.root.join("src/ui/Button.tsx");
|
||||
let abs = abs.to_string_lossy().into_owned();
|
||||
assert_eq!(files(&idx, &abs)[0], "src/ui/Button.tsx");
|
||||
// A trailing `:line:col`, and a path outside the project that names no file.
|
||||
assert_eq!(files(&idx, &format!("{abs}:12:4"))[0], "src/ui/Button.tsx");
|
||||
let outside = fx.root.parent().unwrap().join("elsewhere/Button.tsx");
|
||||
assert!(files(&idx, &outside.to_string_lossy()).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn find_dirs_ranks_folder_names() {
|
||||
let f = sample();
|
||||
|
||||
@@ -25,7 +25,7 @@ impl LspManager {
|
||||
/// Whether jdtls serves the Java files of `path`. Without it, launches build with the
|
||||
/// build tool and take the classpath from [`Self::java_server_classpath`] or the build model.
|
||||
pub fn java_served_by_jdtls(&self, path: &Path) -> bool {
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS && !s.gave_up())
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS)
|
||||
}
|
||||
|
||||
/// The java-analyzer executable among the Java servers of `path`, whatever the server is
|
||||
@@ -107,27 +107,6 @@ fn is_java_analyzer(binary: &Path) -> bool {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::server::Conn;
|
||||
use ide_core::event::ServerStatus;
|
||||
use ide_language::LanguageRegistry;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[test]
|
||||
fn missing_jdtls_leaves_java_analyzer_to_serve_the_module() {
|
||||
let project = tempfile::tempdir().unwrap();
|
||||
let root = project.path();
|
||||
let manager =
|
||||
LspManager::new(root.to_path_buf(), Arc::new(LanguageRegistry::load(None).unwrap()), Arc::new(|_| {}));
|
||||
assert!(manager.java_served_by_jdtls(root));
|
||||
assert!(manager.java_analyzer_binary(root).is_none());
|
||||
|
||||
let jdtls = manager.servers_for(&LanguageId::new("java"), root).into_iter().find(|s| s.name == JDTLS).unwrap();
|
||||
let generation = jdtls.begin_start().unwrap();
|
||||
assert!(jdtls.fail_start(generation, Conn::Missing, manager.sink(), ServerStatus::Missing, None));
|
||||
|
||||
assert!(!manager.java_served_by_jdtls(root));
|
||||
assert_eq!(manager.java_analyzer_binary(root).as_deref(), Some(Path::new("java-analyzer")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recognises_java_analyzer_by_its_executable() {
|
||||
|
||||
@@ -349,9 +349,64 @@ impl RemoteService {
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let fs = self.fs(connection).await?;
|
||||
let r = download_into(&fs, remotes, dir, cancel, progress).await;
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(&fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
fs.close().await;
|
||||
r
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
// --- save hook -----------------------------------------------------------------
|
||||
@@ -601,75 +656,6 @@ fn cache_key(connection: &FsConnection) -> String {
|
||||
}
|
||||
|
||||
/// Files and folders under remote folder `dir` (symlinked folders are not followed).
|
||||
/// `remotes` (folders recursively) into the local folder `dir`, each under its own name, without
|
||||
/// the remote path above it; existing files are replaced. Remote Host › Download to…, and the
|
||||
/// project view's Download to… in a remote project.
|
||||
pub async fn download_into(
|
||||
fs: &RemoteFs,
|
||||
remotes: &[String],
|
||||
dir: &Path,
|
||||
cancel: &CancellationToken,
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
async fn remote_tree(
|
||||
fs: &RemoteFs,
|
||||
dir: &str,
|
||||
|
||||
@@ -631,11 +631,9 @@ fn spring_boot_apps(root: &Path, build: &Path, out: &mut Vec<RunConfig>) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The module has main sources and Spring Boot on its classpath, as far as its build files
|
||||
/// tell: its own build, or a build above it in `build` that hands Spring Boot to its modules,
|
||||
/// references it (a dependency, the starter parent, the BOM or the plugin). A Maven module that
|
||||
/// depends on Spring Boot through a parent or another module is a Spring Boot application even
|
||||
/// without the packaging plugin; only `<pluginManagement>` alone doesn't count.
|
||||
/// The module has main sources, and its build applies the Spring Boot plugin: its own build
|
||||
/// file, or a build above it in `build` that applies it to its modules (a parent POM's
|
||||
/// `<build><plugins>`, Gradle's `subprojects` / `allprojects`).
|
||||
fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if !["java", "kotlin"].iter().any(|l| module.join("src/main").join(l).is_dir()) {
|
||||
return false;
|
||||
@@ -644,19 +642,15 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if pom.contains("<packaging>pom</packaging>") {
|
||||
return false;
|
||||
}
|
||||
if references_spring_boot(&without_plugin_management(&pom)) {
|
||||
if pom.contains("spring-boot-maven-plugin") {
|
||||
return true;
|
||||
}
|
||||
} else if GRADLE_BUILDS
|
||||
.iter()
|
||||
.filter_map(|n| read(&module.join(n)))
|
||||
.any(|text| applies_boot_gradle_plugin(&text) || text.contains("org.springframework.boot:"))
|
||||
{
|
||||
} else if GRADLE_BUILDS.iter().filter_map(|n| read(&module.join(n))).any(|text| applies_boot_gradle_plugin(&text)) {
|
||||
return true;
|
||||
}
|
||||
module.ancestors().skip(1).take_while(|dir| dir.starts_with(build)).any(|dir| {
|
||||
if let Some(pom) = read(&dir.join("pom.xml")) {
|
||||
return references_spring_boot(&without_plugin_management(&pom));
|
||||
return without_plugin_management(&pom).contains("spring-boot-maven-plugin");
|
||||
}
|
||||
GRADLE_BUILDS.iter().filter_map(|n| read(&dir.join(n))).any(|text| {
|
||||
(text.contains("subprojects") || text.contains("allprojects")) && applies_boot_gradle_plugin(&text)
|
||||
@@ -664,14 +658,6 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
/// A POM (without its `<pluginManagement>`) referencing Spring Boot: a dependency or the parent
|
||||
/// (`org.springframework.boot`), a starter, the BOM import or the plugin.
|
||||
fn references_spring_boot(pom: &str) -> bool {
|
||||
["org.springframework.boot", "spring-boot-starter", "spring-boot-dependencies", "spring-boot-maven-plugin"]
|
||||
.iter()
|
||||
.any(|m| pom.contains(m))
|
||||
}
|
||||
|
||||
/// A Gradle build applying the plugin (`id("org.springframework.boot")`, `apply plugin: '…'`),
|
||||
/// not only depending on Spring Boot (`org.springframework.boot:…`).
|
||||
fn applies_boot_gradle_plugin(text: &str) -> bool {
|
||||
|
||||
@@ -1112,12 +1112,8 @@ fn module_count(root: &Path) -> usize {
|
||||
/// named after its `artifactId` (usually its folder), a Gradle one `<project>.<path>.<source set>`.
|
||||
fn module_dir(root: &Path, name: &str) -> Option<String> {
|
||||
let folder = |dir: &Path| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
// A Maven module is named after its artifactId, so that match wins over a folder of the same
|
||||
// name anywhere above it (a checkout folder named like a child module's artifactId).
|
||||
if let Some(dir) = find_module(root, &|dir: &Path| pom_artifact(dir).is_some_and(|a| a == name)) {
|
||||
return Some(dir);
|
||||
}
|
||||
if let Some(dir) = find_module(root, &|dir: &Path| folder(dir) == name) {
|
||||
let exact = |dir: &Path| folder(dir) == name || pom_artifact(dir).is_some_and(|a| a == name);
|
||||
if let Some(dir) = find_module(root, &exact) {
|
||||
return Some(dir);
|
||||
}
|
||||
let gradle = name.strip_suffix(".main").or_else(|| name.strip_suffix(".test")).unwrap_or(name);
|
||||
|
||||
@@ -938,18 +938,7 @@ fn launch_env(root: &Path, config: &RunConfig) -> IdeResult<LaunchEnv> {
|
||||
vars.insert("PYTHONUNBUFFERED".into(), "1".into());
|
||||
}
|
||||
vars.extend(config.env.iter().map(|(k, v)| (k.clone(), v.clone())));
|
||||
let mut env = LaunchEnv { clear: !extras.include_system_env, vars };
|
||||
// `npm.cmd` is found on the login-shell and Windows user PATH, then started by its
|
||||
// full path. The script it runs (`node …`) only sees this process's PATH, which
|
||||
// does not include that directory, so `node` is not recognized.
|
||||
let cwd = resolve_cwd(root, config.cwd.as_deref());
|
||||
if !env.clear && !env.vars.keys().any(|k| k.eq_ignore_ascii_case("PATH")) {
|
||||
let path = crate::wrap::search_path_in(config, &cwd);
|
||||
if let Some(text) = path.to_str().filter(|s| !s.is_empty()) {
|
||||
env.vars.insert("PATH".into(), text.to_owned());
|
||||
}
|
||||
}
|
||||
Ok(env)
|
||||
Ok(LaunchEnv { clear: !extras.include_system_env, vars })
|
||||
}
|
||||
|
||||
/// What a run in the project at `root` inherits with "Include system environment variables"
|
||||
@@ -1457,42 +1446,6 @@ mod tests {
|
||||
assert_eq!(binary.program, script);
|
||||
}
|
||||
|
||||
fn bare_config(env: BTreeMap<String, String>) -> RunConfig {
|
||||
RunConfig {
|
||||
id: "c".into(),
|
||||
name: "c".into(),
|
||||
kind: "npm".into(),
|
||||
command: "npm".into(),
|
||||
args: vec!["run".into(), "start".into()],
|
||||
cwd: None,
|
||||
env,
|
||||
detected: true,
|
||||
is_test: false,
|
||||
debug_adapter: None,
|
||||
allow_parallel: false,
|
||||
extras: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_run_inherits_the_path_used_to_resolve_its_program() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let config = bare_config(BTreeMap::new());
|
||||
let env = launch_env(dir.path(), &config).unwrap();
|
||||
let path = env.vars.get("PATH").expect("child PATH");
|
||||
let search = crate::wrap::search_path_in(&config, dir.path());
|
||||
assert_eq!(path, search.to_str().unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_explicit_path_override_is_kept() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let config = bare_config(BTreeMap::from([("Path".into(), r"C:\tools".into())]));
|
||||
let env = launch_env(dir.path(), &config).unwrap();
|
||||
assert_eq!(env.vars.get("Path").map(String::as_str), Some(r"C:\tools"));
|
||||
assert_eq!(env.vars.keys().filter(|k| k.eq_ignore_ascii_case("PATH")).count(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shell_lines_use_cmd_verbatim_on_windows() {
|
||||
let line = r#"(if not exist "C:\T\openidea-run" mkdir "C:\T\openidea-run") && "C:\Program Files\rustc.exe" -o "C:\T\openidea-run\hi.exe" hi.rs"#;
|
||||
|
||||
@@ -380,57 +380,25 @@ fn a_root_build_disables_the_nested_scan() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spring_boot_applications_need_spring_boot_and_a_main() {
|
||||
fn spring_boot_applications_need_the_plugin_and_a_main() {
|
||||
let main =
|
||||
"package demo;\n@SpringBootApplication\npublic class App {\n public static void main(String[] args) {}\n}\n";
|
||||
// A module without Spring Boot in its build, a configuration class without `main`, the
|
||||
// annotation in a comment, a parent POM.
|
||||
// A library using Spring Boot without the plugin, a configuration class without `main`,
|
||||
// the annotation in a comment, a parent POM.
|
||||
let dir = project(&[
|
||||
("plain/pom.xml", "<project><dependencies>commons-lang3</dependencies></project>"),
|
||||
("plain/src/main/java/demo/App.java", main),
|
||||
("lib/pom.xml", "<project><dependencies>spring-boot-starter</dependencies></project>"),
|
||||
("lib/src/main/java/demo/App.java", main),
|
||||
("svc/pom.xml", BOOT_POM),
|
||||
("svc/src/main/java/demo/Config.java", "package demo;\n@SpringBootApplication\npublic class Config {}\n"),
|
||||
(
|
||||
"svc/src/main/java/demo/Old.java",
|
||||
"package demo;\n// @SpringBootApplication\nclass Old { public static void main(String[] a) {} }\n",
|
||||
),
|
||||
("gr/build.gradle", "dependencies { implementation 'com.google.guava:guava:33.0.0-jre' }\n"),
|
||||
("gr/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert!(!c.iter().any(|c| c.kind == "spring-boot"), "{:?}", ids(&c));
|
||||
}
|
||||
|
||||
/// Spring Boot on the classpath is enough, as for IntelliJ IDEA: a module depending on a
|
||||
/// starter (directly or through its parent POM) without the packaging plugin, and Gradle's
|
||||
/// dependency on `org.springframework.boot:…`.
|
||||
#[test]
|
||||
fn spring_boot_applications_without_the_plugin() {
|
||||
let main =
|
||||
"package demo;\n@SpringBootApplication\npublic class App {\n public static void main(String[] args) {}\n}\n";
|
||||
let dir = project(&[
|
||||
(
|
||||
"lib/pom.xml",
|
||||
"<project><dependencies><dependency><groupId>org.springframework.boot</groupId>\
|
||||
<artifactId>spring-boot-starter-web</artifactId></dependency></dependencies></project>",
|
||||
),
|
||||
("lib/src/main/java/demo/App.java", main),
|
||||
("gr/build.gradle", "dependencies { implementation 'org.springframework.boot:spring-boot-starter' }\n"),
|
||||
("gr/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert_eq!(find(&c, "application:lib:demo.App").kind, "spring-boot");
|
||||
assert_eq!(find(&c, "application:gr:demo.App").kind, "spring-boot");
|
||||
|
||||
let parent = "<project><packaging>pom</packaging><modules><module>job</module></modules>\
|
||||
<parent><groupId>org.springframework.boot</groupId>\
|
||||
<artifactId>spring-boot-starter-parent</artifactId></parent></project>";
|
||||
let dir = project(&[
|
||||
("pom.xml", parent),
|
||||
("job/pom.xml", "<project><artifactId>job</artifactId></project>"),
|
||||
("job/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
assert_eq!(find(&detect(dir.path()), "application:job:demo.App").kind, "spring-boot");
|
||||
assert!(!c.iter().any(|c| c.kind == "spring-boot"), "{:?}", ids(&c));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -860,38 +860,6 @@ fn java_applications_and_spring_boot_keep_their_module() {
|
||||
assert_eq!(reason(&r, "NoMain"), &SkipReason::NothingToRun);
|
||||
}
|
||||
|
||||
/// A checkout folder named like a child module's artifactId: IDEA's module is the child.
|
||||
#[test]
|
||||
fn maven_module_artifact_wins_over_a_folder_of_the_same_name() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(dir.path()).unwrap().join("demo-service");
|
||||
write(
|
||||
&root,
|
||||
"pom.xml",
|
||||
"<project><artifactId>demo-service-parent</artifactId><packaging>pom</packaging></project>",
|
||||
);
|
||||
write(
|
||||
&root,
|
||||
"app-web/pom.xml",
|
||||
"<project><parent><artifactId>demo-service-parent</artifactId></parent><artifactId>demo-service</artifactId></project>",
|
||||
);
|
||||
write(
|
||||
&root,
|
||||
".run/Demo.run.xml",
|
||||
&run_file(
|
||||
"Demo",
|
||||
r#"<configuration name="Demo" type="Application" factoryName="Application">
|
||||
<module name="demo-service" />
|
||||
<option name="MAIN_CLASS_NAME" value="com.example.Demo" />
|
||||
</configuration>"#,
|
||||
),
|
||||
);
|
||||
|
||||
let r = import_from(&root, &[]);
|
||||
|
||||
assert_eq!(get(&r, "Demo").extras.module.as_deref(), Some("app-web"));
|
||||
}
|
||||
|
||||
/// IDEA writes the working directory as a URL. On Windows `file://$PROJECT_DIR$`
|
||||
/// expands to `file://C:/project`, where the drive letter sits where the authority
|
||||
/// belongs; read as a path that is `C:project`, which resolves against the project
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use crate::editorconfig::{EditorConfig, EditorConfigProps};
|
||||
use crate::file_defaults::FileDefaults;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, SharedSink, TextEdit};
|
||||
use ide_text::{AppliedChange, ByteEdit, Document, LineEnding};
|
||||
use parking_lot::{Mutex, ReentrantMutex, RwLock};
|
||||
@@ -1137,24 +1138,6 @@ impl Documents {
|
||||
})
|
||||
}
|
||||
|
||||
/// Load Changes from Disk: drops the buffer's unsaved changes and reads its file again in
|
||||
/// the buffer's encoding, after the file changed on disk (`IdeEvent::DocDiskConflict`).
|
||||
pub fn discard_and_reload(&self, doc: DocId) -> IdeResult<()> {
|
||||
self.with_doc(doc, |st| {
|
||||
if st.uri.is_some() || st.binary {
|
||||
return Err(IdeError::invalid("only a file's text can be reloaded from disk"));
|
||||
}
|
||||
let loaded = Self::load_as(&st.path, &st.encoding, st.native_to_ascii)?;
|
||||
st.has_bom = loaded.has_bom;
|
||||
st.disk_mtime = loaded.mtime_ms;
|
||||
st.disk_len = disk_len(&st.path);
|
||||
st.disk_conflict = false;
|
||||
self.replace_locked(doc, st, &loaded.text)?;
|
||||
self.set_dirty(doc, st, false);
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
/// The URI of a virtual document, or `None` for a file-backed one.
|
||||
pub fn virtual_uri(&self, doc: DocId) -> IdeResult<Option<String>> {
|
||||
self.with_doc(doc, |st| Ok(st.uri.clone()))
|
||||
@@ -1267,7 +1250,7 @@ impl Documents {
|
||||
}
|
||||
|
||||
/// Re-reads from disk after an external change. Clean documents reload
|
||||
/// silently; dirty ones are left alone and reported via `IdeEvent::DocDiskConflict`.
|
||||
/// silently; dirty ones are left alone and reported via `IdeEvent::Notify`.
|
||||
/// Changes matching our own last save are ignored.
|
||||
pub fn on_disk_changed(&self, paths: &[PathBuf]) {
|
||||
self.reload_from_disk(paths, false, false);
|
||||
@@ -1306,7 +1289,16 @@ impl Documents {
|
||||
st.disk_mtime = mtime;
|
||||
st.disk_len = meta.len();
|
||||
st.disk_conflict = true;
|
||||
self.sink.emit(IdeEvent::DocDiskConflict { doc: id, path: st.path.to_string_lossy().into_owned() });
|
||||
let name = st.path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
self.sink.emit(IdeEvent::Notify {
|
||||
level: NotifyLevel::Warning,
|
||||
title: format!("{name} changed on disk"),
|
||||
body: Some(format!(
|
||||
"{} was modified externally but has unsaved changes in the editor. \
|
||||
Saving explicitly will overwrite the external changes; autosave leaves the file alone.",
|
||||
st.path.display()
|
||||
)),
|
||||
});
|
||||
return Ok(());
|
||||
}
|
||||
let loaded = if force_clean {
|
||||
|
||||
@@ -850,7 +850,6 @@ mod tests {
|
||||
"agent": "",
|
||||
"agentModel": "",
|
||||
"agentEffort": "",
|
||||
"agentButton": true,
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::{ChangeSet, DocId, IdeEvent, LanguageId, Pos, Range, SharedSink, TextChange, TextEdit};
|
||||
use ide_text::{AppliedChange, LineEnding};
|
||||
use ide_workspace::documents::DocumentObserver;
|
||||
@@ -564,31 +565,15 @@ fn external_changes() {
|
||||
fs::write(&path, "something else\n").unwrap();
|
||||
f.docs.on_disk_changed(std::slice::from_ref(&path));
|
||||
assert_eq!(f.docs.snapshot(id).unwrap().text, "// alpha\nBETA\ngamma\n");
|
||||
let warnings = f
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| matches!(e, IdeEvent::DocDiskConflict { path: p, .. } if *p == path.to_string_lossy()))
|
||||
.count();
|
||||
let warnings =
|
||||
f.events.lock().iter().filter(|e| matches!(e, IdeEvent::Notify { level: NotifyLevel::Warning, .. })).count();
|
||||
assert_eq!(warnings, 1);
|
||||
// The same disk state is reported only once.
|
||||
f.docs.on_disk_changed(std::slice::from_ref(&path));
|
||||
let warnings = f
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| matches!(e, IdeEvent::DocDiskConflict { path: p, .. } if *p == path.to_string_lossy()))
|
||||
.count();
|
||||
let warnings =
|
||||
f.events.lock().iter().filter(|e| matches!(e, IdeEvent::Notify { level: NotifyLevel::Warning, .. })).count();
|
||||
assert_eq!(warnings, 1);
|
||||
|
||||
// Load Changes from Disk drops the buffer's changes; autosave writes again afterwards.
|
||||
f.docs.discard_and_reload(id).unwrap();
|
||||
let reloaded = f.docs.snapshot(id).unwrap();
|
||||
assert_eq!((reloaded.text.as_str(), reloaded.dirty), ("something else\n", false));
|
||||
f.docs.edit(id, reloaded.version, change(0, 0, "# ")).unwrap();
|
||||
assert!(f.docs.autosave(id).unwrap());
|
||||
assert_eq!(fs::read_to_string(&path).unwrap(), "# something else\n");
|
||||
|
||||
// Unknown paths are ignored.
|
||||
f.docs.on_disk_changed(&[f.root.join("other.txt")]);
|
||||
}
|
||||
|
||||
@@ -55,9 +55,7 @@ Codex keeps its own project trust decision. If it disables the current project's
|
||||
<Step title="Pick the agent and its settings">
|
||||
Choose the agent, and its model, mode and other options when it offers them. Cached models appear immediately; the selected agent's catalog refreshes in the background when it is more than 15 minutes old, without sending a prompt or attaching project MCP servers.
|
||||
|
||||
Click the model name to switch models, or click the settings beside it (for example **High · 1M**) to change effort or context size directly. In the model list, use the arrow on a model's row to see its settings without selecting it. Changing a setting selects that model; going back without an edit keeps the previous selection. These controls are also available in an existing chat.
|
||||
|
||||
If settings aren't cached, OpenIDEA looks them up when you select or inspect the model. No prompt is sent. Each model keeps its own draft choices, and models that report no effort control do not borrow another model's levels.
|
||||
Model-specific effort levels and context options are looked up when you select a model whose settings are not cached, even before its first task. **Loading model settings…** appears beside the model during this short-lived lookup; no prompt is sent and existing tasks are not changed. Each model keeps its own choices, and models that report no effort control do not borrow another model's levels.
|
||||
|
||||
After changing the agent CLI or account, open the model picker and choose **Refresh models**. Refreshes share one lookup and have a 30-second cooldown after completion, including failures. Selecting an uncached model's settings does not wait for another model's cooldown. Cached choices remain usable while refreshing or after a failure; use **Refresh models** to retry a failed lookup after its cooldown.
|
||||
|
||||
|
||||
@@ -57,7 +57,6 @@ Language servers that support LSP inline completion show a grey suggestion at th
|
||||
| **Next Method** / **Previous Method** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
- **Go to Declaration or Usages** on a declaration shows its usages instead.
|
||||
- **Go to Implementation(s)** navigates to the symbol's own declaration when it has no implementations, as in IntelliJ IDEA.
|
||||
- Hold `⌘` / `Ctrl` and hover over a name to see it underlined as a link, with brief information about it.
|
||||
- Gutter icons mark types and methods that are implemented or overridden (↓) and methods that implement or override another (↑). Click one to go there.
|
||||
- **Navigate › Test** jumps between a class and its tests by naming convention and offers **Create New Test…** when there is none.
|
||||
|
||||
@@ -23,7 +23,7 @@ Only types you add appear here: choose **Add Service › Run Configuration Type*
|
||||
- Configuration actions: **Run** (or **Rerun**), **Debug**, **Stop**, **Open in Browser**, **Update Application** (for configurations that support it).
|
||||
- Context menu: **Show in Run Tool Window**, **Show in Debug Tool Window**, **Edit Configuration…**, **Remove from Services**.
|
||||
|
||||
A configuration that ran shows its console in the detail pane; one debugged from here shows the whole debugger there (Threads & Variables, Console, Memory), and a breakpoint keeps the Services tool window in front. Reorder configurations within a group by dragging them or with **Move Up** / **Move Down**; the order is saved per project.
|
||||
A configuration that ran shows its console in the detail pane. Reorder configurations within a group by dragging them or with **Move Up** / **Move Down**; the order is saved per project.
|
||||
|
||||
## Docker
|
||||
|
||||
|
||||
@@ -43,7 +43,7 @@ It reads repository state (status, diffs, blame, log) in-process, and runs the `
|
||||
- When creating a project, check **Create Git repository** in the New Project dialog.
|
||||
- **Git › Create Git Repository…** runs `git init` in a folder you pick (the project root by default) and registers the new repository right away; a repository created in the terminal is picked up the same way.
|
||||
|
||||
OpenIDEA finds the repository that contains the project and nested repositories up to four levels deep (skipping folders such as `node_modules`, `target` and `build`). Status, commit, fetch and update cover all of them; branch operations from the branches popup cover all of them too (see [Branches](#branches)); log actions work on the selected repository. Submodules show as nested repositories, without submodule commands.
|
||||
OpenIDEA finds the repository that contains the project and nested repositories up to four levels deep (skipping folders such as `node_modules`, `target` and `build`). Status, commit, fetch and update cover all of them; branch and log actions work on the selected repository. Submodules show as nested repositories, without submodule commands.
|
||||
|
||||
## Commit changes
|
||||
|
||||
@@ -143,7 +143,7 @@ Select a branch (`→` or `Enter`) for its actions:
|
||||
|
||||
If local changes block a checkout, you can choose **Smart Checkout** (stash, check out, unstash), **Force Checkout** or **Don't Checkout**. A deleted branch can be brought back with **Restore** in the notification.
|
||||
|
||||
With several repositories, the popup shows branches common to all of them, plus a submenu per repository; an operation on a common branch (Checkout, Checkout and Rebase, Rebase, Merge, Update, Rename, Delete…) runs in every repository, and if it fails in one of them, OpenIDEA offers to roll back the others. When the repositories are on different branches, the popup says **Branches have diverged** and still lists the common branches, so checking one out brings them back in step. Turn off **Execute branch operations on all repositories** in the Git settings to list and act on the selected repository only.
|
||||
With several repositories, the popup shows branches common to all of them, plus a submenu per repository.
|
||||
|
||||
## Sync with remotes
|
||||
|
||||
@@ -178,7 +178,6 @@ The **Log** tab of the Git tool window shows the commit graph.
|
||||
- **Graph Options**: sort by date, topologically or incoming first; first parent only; no merges.
|
||||
- **View Options**: reference display, details pane, and columns (**Author**, **Date**, **Hash**, **Signature**, **GitHub Commit Checks**).
|
||||
- The branches pane on the left filters the log by branch and has branch actions. Select several local branches and choose **Update Selected** to fast-forward each to its tracked branch, fetching each remote once; one notification lists the branches that were updated and those that could not be fast-forwarded or have no tracked branch.
|
||||
- With several repositories, the branches pane lists each branch once; a branch that only some repositories have shows their names after it in grey, and its actions run in those repositories. **Group by Repository** in the pane's toolbar shows one subtree per repository instead.
|
||||
- The details pane shows the changed files, the commit message, who committed it, which branches contain it and its signature.
|
||||
|
||||
Right-click a commit for **Copy Revision Number** (`⌥⇧⌘C` / `Ctrl+Alt+Shift+C`), **Create Patch…**, **Cherry-Pick**, **Checkout Revision**, **Browse Repository at Revision**, **Compare with Local**, **Reset Current Branch to Here…**, **Revert Commit**, **Undo Commit…**, **New Branch…**, **New Tag…**, **View in Browser** and more. With two commits selected, **Compare Versions** diffs them.
|
||||
@@ -239,16 +238,16 @@ Retention is set in the **Local History** section of **Settings › Appearance &
|
||||
|
||||
**Settings › Version Control** has these pages:
|
||||
|
||||
| Page | Main options |
|
||||
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **Commit** | Non-modal commit interface, clearing the message after commit, message inspections (blank line after subject, subject and body length, right margin), default commit checks. |
|
||||
| **Confirmation** | What to do when files are created or deleted, **Show options before Update**, confirm before dropping commits, highlight modified folders in the Project view, history row limit. |
|
||||
| **Directory Mappings** | The detected repositories (read-only). |
|
||||
| **Issue Navigation** | Regex patterns that turn issue IDs in commit messages into links (presets for JIRA, YouTrack and GitHub). |
|
||||
| **Log** | Reference and time display, visible columns. |
|
||||
| **Shelf** | Remove applied files from the shelf. |
|
||||
| **Git** | Git executable, inline blame, commit warnings, sign-off default, push options and protected branches, update method (merge or rebase), incoming-commit checks, saved passwords, combining stash and shelf, branch operations on all repositories. |
|
||||
| **GitHub** | See [GitHub](/en/guide/github). |
|
||||
| Page | Main options |
|
||||
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **Commit** | Non-modal commit interface, clearing the message after commit, message inspections (blank line after subject, subject and body length, right margin), default commit checks. |
|
||||
| **Confirmation** | What to do when files are created or deleted, **Show options before Update**, confirm before dropping commits, highlight modified folders in the Project view, history row limit. |
|
||||
| **Directory Mappings** | The detected repositories (read-only). |
|
||||
| **Issue Navigation** | Regex patterns that turn issue IDs in commit messages into links (presets for JIRA, YouTrack and GitHub). |
|
||||
| **Log** | Reference and time display, visible columns. |
|
||||
| **Shelf** | Remove applied files from the shelf. |
|
||||
| **Git** | Git executable, inline blame, commit warnings, sign-off default, push options and protected branches, update method (merge or rebase), incoming-commit checks, saved passwords, combining stash and shelf. |
|
||||
| **GitHub** | See [GitHub](/en/guide/github). |
|
||||
|
||||
## Not supported
|
||||
|
||||
|
||||
@@ -55,9 +55,7 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex
|
||||
<Step title="选择 agent 及其设置">
|
||||
选择 agent,以及它提供的模型、模式等选项。缓存的模型会立即显示;所选 agent 的模型列表超过 15 分钟未更新时,会在后台刷新,不发送提示词,也不接入项目 MCP 服务器。
|
||||
|
||||
点击模型名称可切换模型;点击旁边的设置(如 **High · 1M**)可直接调整思考强度或上下文大小。在模型列表中,点击一行右侧的箭头可以先查看该模型的设置。修改设置时才会选中该模型,直接返回则保留原来的选择。在已有对话中也可以这样操作。
|
||||
|
||||
选择模型或查看其设置时,如果还没有缓存,OpenIDEA 会按需查询,无需发送提示词。草稿分别保留各模型的选择;未提供思考强度的模型不会沿用其他模型的选项。
|
||||
选择尚未缓存设置的模型时,会按需查询该模型的思考强度和上下文选项,无需先运行任务。短暂查询期间,模型旁会显示**正在加载模型设置…**;查询不发送提示词,也不更改现有任务。每个模型分别保留你选择的设置;明确不提供思考强度的模型不会沿用其他模型的强度选项。
|
||||
|
||||
更改 agent CLI 或账号后,打开模型选择器并单击 **刷新模型**。并发刷新会共用一次查询;每次查询完成后(包括失败)都有 30 秒冷却时间。查询其他未缓存模型的设置无需等待前一个模型的冷却时间。刷新中或刷新失败后,缓存选项仍可使用;查询失败后,可在冷却结束后用**刷新模型**重试。
|
||||
|
||||
|
||||
@@ -57,7 +57,6 @@ description: "代码补全、导航、查找用法、文档、层次结构与文
|
||||
| **下一个方法** / **上一个方法** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
- 在声明本身上执行 **转到声明或用法**,会改为显示它的用法。
|
||||
- 没有任何实现时,**转到实现** 会跳转到符号自身的声明,与 IntelliJ IDEA 一致。
|
||||
- 按住 `⌘` / `Ctrl` 把鼠标悬停在名称上,名称会显示为链接,并附带简要信息。
|
||||
- 装订区域的图标标出被实现或被重写的类型和方法(↓),以及实现或重写了其他方法的方法(↑),单击即可跳转。
|
||||
- **导航 › 测试** 按命名约定在类和它的测试之间跳转;还没有测试时会提供 **创建新测试…**。
|
||||
|
||||
@@ -23,7 +23,7 @@ description: "在服务工具窗口中管理运行配置、Docker 容器、镜
|
||||
- 配置操作:**运行**(或 **重新运行**)、**调试**、**停止**、**在浏览器中打开**、**更新应用**(仅支持的配置)。
|
||||
- 右键菜单:**在运行工具窗口中显示**、**在调试工具窗口中显示**、**编辑配置…**、**从服务中移除**。
|
||||
|
||||
运行过的配置会在详情区显示其控制台;从这里调试的配置在详情区显示完整的调试器(线程和变量、控制台、内存),命中断点时停留在服务工具窗口。在同一分组内可以拖动或用 **上移** / **下移** 调整顺序,顺序按项目保存。
|
||||
运行过的配置会在详情区显示其控制台。在同一分组内可以拖动或用 **上移** / **下移** 调整顺序,顺序按项目保存。
|
||||
|
||||
## Docker
|
||||
|
||||
|
||||
@@ -43,7 +43,7 @@ OpenIDEA 内置 Git 支持,Git 也是它唯一支持的版本控制系统。
|
||||
- 新建项目时,在新建项目对话框中勾选 **创建 Git 仓库**。
|
||||
- **Git › 创建 Git 仓库…** 会在你选择的目录(默认是项目根目录)里执行 `git init`,并立即注册这个新仓库;在终端里创建的仓库同样会被识别。
|
||||
|
||||
OpenIDEA 会找到包含项目的仓库,以及向下最多四层的嵌套仓库(跳过 `node_modules`、`target`、`build` 等目录)。状态、提交、获取和更新覆盖所有仓库;分支弹窗中的分支操作同样覆盖所有仓库(见[分支](#分支));日志操作针对所选仓库。子模块显示为嵌套仓库,但没有子模块相关命令。
|
||||
OpenIDEA 会找到包含项目的仓库,以及向下最多四层的嵌套仓库(跳过 `node_modules`、`target`、`build` 等目录)。状态、提交、获取和更新覆盖所有仓库;分支和日志操作针对所选仓库。子模块显示为嵌套仓库,但没有子模块相关命令。
|
||||
|
||||
## 提交更改
|
||||
|
||||
@@ -141,7 +141,7 @@ OpenIDEA 会找到包含项目的仓库,以及向下最多四层的嵌套仓
|
||||
|
||||
如果本地更改阻止签出,可以选择 **智能签出**(贮藏、签出、再恢复)、**强制签出** 或 **不签出**。删除的分支可以通过通知中的 **恢复** 找回。
|
||||
|
||||
有多个仓库时,弹窗会显示所有仓库共有的分支,以及每个仓库各自的子菜单;对公共分支的操作(签出、签出并变基、变基、合并、更新、重命名、删除等)会在每个仓库中执行,如果在某个仓库失败,OpenIDEA 会提议回滚其他仓库。各仓库处于不同分支时,弹窗会提示**分支已分叉**,但仍列出公共分支,检出其中一个即可让各仓库回到同一分支。在 Git 设置中关闭**在所有仓库执行分支操作**后,弹窗只列出并操作所选仓库。
|
||||
有多个仓库时,弹窗会显示所有仓库共有的分支,以及每个仓库各自的子菜单。
|
||||
|
||||
## 与远程同步
|
||||
|
||||
@@ -176,7 +176,6 @@ Git 工具窗口的 **日志** 标签页显示提交图。
|
||||
- **图形选项**:按日期、拓扑或传入优先排序;仅第一父提交;不显示合并提交。
|
||||
- **视图选项**:引用显示方式、详情面板,以及列(**作者**、**日期**、**哈希**、**签名**、**GitHub 提交检查**)。
|
||||
- 左侧的分支面板可以按分支过滤日志,并提供分支操作。选中多个本地分支后选择 **Update Selected**,会把每个分支快进到它的跟踪分支,每个远程只 fetch 一次;结果汇总在一条通知里,列出已更新的分支,以及因不能快进或没有跟踪分支而未更新的分支。
|
||||
- 有多个仓库时,分支面板中每个分支只列一次;只存在于部分仓库的分支,后面会以灰字列出这些仓库,对它的操作会在这些仓库中执行。点击面板工具栏中的**按仓库分组**,可改为每个仓库一棵子树。
|
||||
- 详情面板显示变更文件、提交消息、提交者、包含该提交的分支以及签名。
|
||||
|
||||
右键提交可以选择 **复制修订号**(`⌥⇧⌘C` / `Ctrl+Alt+Shift+C`)、**创建补丁…**、**拣选**、**签出修订**、**浏览此修订版本的仓库**、**与本地比较**、**将当前分支重置到此处…**、**还原提交**、**撤消提交…**、**新建分支…**、**新建标签…**、**在浏览器中查看** 等。选中两个提交时,**比较版本** 会比较它们。
|
||||
@@ -237,16 +236,16 @@ Git 工具窗口的 **日志** 标签页显示提交图。
|
||||
|
||||
**设置 › 版本控制** 包含以下页面:
|
||||
|
||||
| 页面 | 主要选项 |
|
||||
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **提交** | 非模态提交界面、提交后清空消息、提交消息检查(主题与正文之间空行、主题和正文长度、右边距)、默认提交检查。 |
|
||||
| **确认** | 新建或删除文件时的处理方式、**更新前显示选项**、丢弃提交前确认、在项目视图中高亮包含修改的目录、历史记录行数上限。 |
|
||||
| **目录映射** | 检测到的仓库(只读)。 |
|
||||
| **问题导航** | 把提交消息中的问题编号变成链接的正则规则(内置 JIRA、YouTrack 和 GitHub 预设)。 |
|
||||
| **日志** | 引用和时间的显示方式、显示哪些列。 |
|
||||
| **搁置** | 应用后从搁置中移除文件。 |
|
||||
| **Git** | Git 可执行文件、内联 Blame、提交警告、默认签署、推送选项和受保护分支、更新方式(合并或变基)、传入提交检查、已保存的密码、合并显示贮藏和搁置、在所有仓库执行分支操作。 |
|
||||
| **GitHub** | 见 [GitHub](/zh/guide/github)。 |
|
||||
| 页面 | 主要选项 |
|
||||
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **提交** | 非模态提交界面、提交后清空消息、提交消息检查(主题与正文之间空行、主题和正文长度、右边距)、默认提交检查。 |
|
||||
| **确认** | 新建或删除文件时的处理方式、**更新前显示选项**、丢弃提交前确认、在项目视图中高亮包含修改的目录、历史记录行数上限。 |
|
||||
| **目录映射** | 检测到的仓库(只读)。 |
|
||||
| **问题导航** | 把提交消息中的问题编号变成链接的正则规则(内置 JIRA、YouTrack 和 GitHub 预设)。 |
|
||||
| **日志** | 引用和时间的显示方式、显示哪些列。 |
|
||||
| **搁置** | 应用后从搁置中移除文件。 |
|
||||
| **Git** | Git 可执行文件、内联 Blame、提交警告、默认签署、推送选项和受保护分支、更新方式(合并或变基)、传入提交检查、已保存的密码、合并显示贮藏和搁置。 |
|
||||
| **GitHub** | 见 [GitHub](/zh/guide/github)。 |
|
||||
|
||||
## 暂不支持
|
||||
|
||||
|
||||
@@ -109,7 +109,6 @@ async function seed(
|
||||
model = "atlas",
|
||||
status: AgentTask["status"] = "ready",
|
||||
catalogOnly = false,
|
||||
offered = provider,
|
||||
) {
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
@@ -219,7 +218,7 @@ async function seed(
|
||||
if (surface === "new") store.openHome();
|
||||
else store.openTask(firstTask.id);
|
||||
},
|
||||
{ placement, surface, provider: offered, firstTask, secondTask, subagent, model, status, modelId, catalogOnly },
|
||||
{ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId, catalogOnly },
|
||||
);
|
||||
await expect(box(page)).toBeVisible();
|
||||
await page.evaluate(() => document.fonts.ready);
|
||||
@@ -234,8 +233,9 @@ function history(page: Page) {
|
||||
function modelButton(page: Page) {
|
||||
return page.getByRole("button", { name: "Model", exact: true }).filter({ visible: true });
|
||||
}
|
||||
/** The effort is shown on the model button, after the model's name. */
|
||||
function effortLabel(page: Page) {
|
||||
return page.getByRole("button", { name: /^Model settings:/ }).filter({ visible: true });
|
||||
return modelButton(page).locator("[class*='modelDetail']");
|
||||
}
|
||||
async function expectEffort(page: Page, name: string) {
|
||||
await expect(effortLabel(page)).toHaveText(name);
|
||||
@@ -284,50 +284,6 @@ async function expectNoSubmission(page: Page) {
|
||||
expect(await ipcCalls(page, "agent_create")).toEqual([]);
|
||||
}
|
||||
|
||||
for (const surface of ["new", "task"] as const) {
|
||||
test(`${surface}: configure another model from its row, then edit its context from the composer`, async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const context = option(
|
||||
"context_tier",
|
||||
"model_config",
|
||||
[
|
||||
["default", "200K"],
|
||||
["long_context", "1M"],
|
||||
],
|
||||
"default",
|
||||
);
|
||||
const offered = {
|
||||
...provider,
|
||||
thoughtLevels: { ...provider.thoughtLevels, atlas: [atlas, context], swift: [swift, context] },
|
||||
};
|
||||
await seed(page, "editor", surface, "atlas", "ready", false, offered);
|
||||
await box(page).fill("Review the project structure");
|
||||
await modelButton(page).click();
|
||||
const row = page.getByRole("option", { name: /^Swift\b/ });
|
||||
await row.hover();
|
||||
const configure = row.getByRole("button", { name: "Configure Swift…" });
|
||||
if (surface === "task") await configure.press("Enter");
|
||||
else await configure.click();
|
||||
await expect(modelButton(page)).toHaveText("Atlas");
|
||||
await expect(page.getByRole("radio", { name: "Gentle" })).toHaveCount(0);
|
||||
await page.getByRole("radio", { name: "Thorough" }).click();
|
||||
await expect(modelButton(page)).toHaveText("Swift");
|
||||
await expect(page.getByRole("radio", { name: "Thorough" })).toBeChecked();
|
||||
await page.keyboard.press("Escape");
|
||||
const settings = page.getByRole("button", { name: /^Model settings:/ });
|
||||
await expect(settings).toHaveText("Thorough · 200K");
|
||||
await settings.click();
|
||||
await page.getByRole("radio", { name: "1M" }).click();
|
||||
await expect(settings).toHaveText("Thorough · 1M");
|
||||
await page.getByRole("button", { name: "Back to models" }).click();
|
||||
await expect(page.getByRole("listbox", { name: "Model", exact: true })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(box(page)).toHaveText("Review the project structure");
|
||||
await expectNoSubmission(page);
|
||||
});
|
||||
}
|
||||
|
||||
for (const placement of ["editor", "toolWindow"] as const) {
|
||||
test(`${placement}: existing task cycles advertised values and wraps without editing, moving focus or scrolling`, async ({
|
||||
workbench: page,
|
||||
@@ -423,7 +379,7 @@ test("Settings and effort popup exclude the agent shortcut", async ({ workbench:
|
||||
await expect(search).toBeFocused();
|
||||
await expect(search).toHaveValue("keymap");
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await effortLabel(page).click();
|
||||
await modelButton(page).click();
|
||||
const popup = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
|
||||
await expect(popup).toBeVisible();
|
||||
await page.keyboard.press("Alt+t");
|
||||
@@ -647,7 +603,7 @@ test("New Task discovers uncached model effort before the first prompt", async (
|
||||
await page.screenshot({ path: testInfo.outputPath("model-settings-loading.png") });
|
||||
await page.evaluate(() => document.dispatchEvent(new Event("test:model-settings-ready")));
|
||||
await expectEffort(page, "Quick");
|
||||
await effortLabel(page).click();
|
||||
await modelButton(page).click();
|
||||
const efforts = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
|
||||
await expect(efforts.getByRole("radio", { name: "Quick", exact: true })).toBeVisible();
|
||||
await expect(efforts.getByRole("radio", { name: "Thorough", exact: true })).toBeVisible();
|
||||
@@ -680,7 +636,7 @@ test("an existing chat can choose effort for a refreshed model before sending",
|
||||
await expect(loading).toHaveCount(0);
|
||||
await expect(modelButton(page)).toHaveAttribute("title", /^Model: Swift\b/);
|
||||
await expectEffort(page, "Quick");
|
||||
await effortLabel(page).click();
|
||||
await modelButton(page).click();
|
||||
const efforts = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
|
||||
await expect(efforts.getByRole("radio", { name: "Gentle", exact: true })).toHaveCount(0);
|
||||
await efforts.getByRole("radio", { name: "Thorough", exact: true }).click();
|
||||
|
||||
@@ -1,68 +0,0 @@
|
||||
import type { AttachableProcess } from "../src/bindings";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("keeps the process columns and selection visible in a short window", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 460, height: 440 });
|
||||
await stubDesktop(page);
|
||||
const processes: AttachableProcess[] = [
|
||||
{
|
||||
pid: 4100,
|
||||
name: "java",
|
||||
commandLine: "java -jar /sample/invoice-service.jar",
|
||||
kind: "java",
|
||||
adapter: "java",
|
||||
host: "localhost",
|
||||
port: 5005,
|
||||
},
|
||||
...Array.from({ length: 24 }, (_, i): AttachableProcess => ({
|
||||
pid: 4201 + i,
|
||||
name: `invoice-worker-${i + 1}`,
|
||||
commandLine: `node /sample/services/long-package-name/invoice-worker.js --stage settlement-runner-${i + 1}`,
|
||||
kind: "node",
|
||||
adapter: "js-debug",
|
||||
host: "localhost",
|
||||
port: 9230 + i,
|
||||
})),
|
||||
];
|
||||
await page.evaluate(async (processes) => {
|
||||
window.__ipc.handlers.debug_attachable_processes = () => processes;
|
||||
const actions = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actions);
|
||||
await executeAction("debug.attachToProcess");
|
||||
}, processes);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Attach to process", exact: true });
|
||||
const filter = dialog.getByRole("textbox", { name: "Filter processes" });
|
||||
await expect(filter).toBeFocused();
|
||||
const table = dialog.getByRole("grid", { name: "Processes" });
|
||||
const pid = table.getByRole("columnheader", { name: "PID", exact: true });
|
||||
await expect(pid).toBeInViewport({ ratio: 1 });
|
||||
await expect(table.getByRole("columnheader", { name: "Command line" })).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await filter.fill("settlement-runner");
|
||||
for (let i = 1; i < 24; i++) await page.keyboard.press("ArrowDown");
|
||||
const last = table.getByRole("row", { name: /^invoice-worker-24 / });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(pid).toBeInViewport({ ratio: 1 });
|
||||
await expect(last.getByText(":9253", { exact: true })).toBeVisible();
|
||||
await expect(last.getByTitle("localhost:9253", { exact: true })).toBeVisible();
|
||||
const lastPid = last.getByRole("gridcell", { name: "4224", exact: true });
|
||||
expect((await lastPid.boundingBox())!.x).toBeCloseTo((await pid.boundingBox())!.x, 0);
|
||||
const scrollArea = table.getByRole("rowgroup").last();
|
||||
expect(await scrollArea.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
expect(await scrollArea.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(filter).toBeFocused();
|
||||
await expect(filter).toBeInViewport({ ratio: 1 });
|
||||
for (const name of ["Refresh", "Attach", "Cancel"]) {
|
||||
await expect(dialog.getByRole("button", { name, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
|
||||
await page.setViewportSize({ width: 1040, height: 680 });
|
||||
await expect(last.getByText("localhost:9253", { exact: true })).toBeVisible();
|
||||
await filter.fill("unmatched-process");
|
||||
await expect(dialog.getByText("No attachable processes match the filter.")).toBeVisible();
|
||||
await expect(dialog.getByRole("button", { name: "Attach", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -1,71 +0,0 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Branch comparison keeps both commit ranges and the diff action visible", async ({ workbench: page }) => {
|
||||
const branch = "feature/settlement-reconciliation-and-international-ledger-reporting";
|
||||
const current = "feature/review-quarterly-settlement-audit";
|
||||
const incomingSubject = "Keep regional settlement references stable during the report export";
|
||||
const outgoingSubject = "Preserve the audit trail for settlement retries";
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ branch, current, incomingSubject, outgoingSubject }) => {
|
||||
const root = "/dev/acme-api";
|
||||
const branchInfo = {
|
||||
head: current,
|
||||
headCommit: "b".repeat(40),
|
||||
upstream: null,
|
||||
ahead: 0,
|
||||
behind: 0,
|
||||
operation: null,
|
||||
};
|
||||
const entry = (letter: string, summary: string) => ({
|
||||
id: letter.repeat(40),
|
||||
shortId: letter.repeat(8),
|
||||
parents: ["a".repeat(40)],
|
||||
refs: [],
|
||||
summary,
|
||||
message: summary + "\n\nUpdate the audit report context.",
|
||||
author: "Sam Rivera",
|
||||
email: "[email protected]",
|
||||
timeMs: 1795100000000,
|
||||
});
|
||||
const h = window.__ipc.handlers;
|
||||
h.vcs_roots = () => [{ root, ...branchInfo }];
|
||||
h.vcs_branch_info = () => branchInfo;
|
||||
h.vcs_status = () => [];
|
||||
h.vcs_log = ({ query }) =>
|
||||
(query as { range: string }).range === `HEAD..${branch}`
|
||||
? [entry("c", incomingSubject)]
|
||||
: [entry("b", outgoingSubject)];
|
||||
h.window_open_comparison = () => null;
|
||||
const store = "/src/features/vcs/store.ts";
|
||||
const { useVcs } = await import(/* @vite-ignore */ store);
|
||||
useVcs.setState({ available: true, root, repo: root, roots: [root], branch: branchInfo });
|
||||
const path = "/src/features/vcs/CompareBranches.tsx";
|
||||
(await import(/* @vite-ignore */ path)).showCompareBranches(branch);
|
||||
},
|
||||
{ branch, current, incomingSubject, outgoingSubject },
|
||||
);
|
||||
const dialog = page.getByRole("dialog", { name: new RegExp(`Compare ${current}`) });
|
||||
await expect(dialog.getByRole("listbox")).toHaveCount(2);
|
||||
const incoming = dialog.getByRole("listbox", { name: `In ${branch}, not in ${current}` });
|
||||
const outgoing = dialog.getByRole("listbox", { name: `In ${current}, not in ${branch}` });
|
||||
await expect(incoming.getByText(incomingSubject, { exact: true })).toBeVisible();
|
||||
await expect(outgoing.getByText(outgoingSubject, { exact: true })).toBeVisible();
|
||||
const divider = dialog.getByRole("separator", { name: "Resize branch comparison panes" });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
const start = (await divider.boundingBox())!.y;
|
||||
await divider.focus();
|
||||
await page.keyboard.press("ArrowDown");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeGreaterThan(start + 1);
|
||||
|
||||
await page.setViewportSize({ width: 440, height: 660 });
|
||||
const heading = dialog.getByRole("heading", { name: new RegExp(`In ${branch}`) });
|
||||
await expect.poll(() => heading.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(incoming.getByRole("option")).toBeVisible();
|
||||
await expect(outgoing.getByRole("option")).toBeVisible();
|
||||
await dialog.getByRole("button", { name: "Show Diff", exact: true }).click();
|
||||
await expect
|
||||
.poll(() => ipcCalls(page, "window_open_comparison"))
|
||||
.toMatchObject([{ comparison: { from: { rev: branch }, to: { rev: "HEAD" }, repo: "/dev/acme-api" } }]);
|
||||
});
|
||||
@@ -1,40 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("Color Scheme keeps the preview visible while editing an attribute in narrow Settings", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
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("Language Defaults");
|
||||
await settings.getByRole("treeitem", { name: "Language Defaults", exact: true }).click();
|
||||
await search.clear();
|
||||
|
||||
const divider = settings.getByRole("separator", { name: "Resize color scheme preview", exact: true });
|
||||
const tree = settings.getByRole("tree", { name: "Color scheme attributes", exact: true });
|
||||
const options = settings.getByRole("region", { name: "Color scheme options", exact: true });
|
||||
const preview = settings.getByLabel("Color scheme preview", { exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
expect((await tree.boundingBox())!.x).toBeLessThan((await options.boundingBox())!.x);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 660 });
|
||||
await expect.poll(async () => (await tree.boundingBox())!.y).toBeLessThan((await options.boundingBox())!.y);
|
||||
const previewTop = (await preview.boundingBox())!.y;
|
||||
const token = preview.getByText("class", { exact: true }).first();
|
||||
await token.click();
|
||||
await expect(tree.getByRole("treeitem", { name: "Keyword", exact: true, selected: true })).toBeVisible();
|
||||
await options.getByRole("textbox", { name: "Foreground hex", exact: true }).fill("#118899");
|
||||
await expect(token).toHaveCSS("color", "rgb(17, 136, 153)");
|
||||
await expect(preview).toBeInViewport();
|
||||
expect((await preview.boundingBox())!.y).toBeCloseTo(previewTop, 0);
|
||||
await expect
|
||||
.poll(() => settings.locator("[class*='pageBody']").evaluate((el) => el.scrollWidth - el.clientWidth))
|
||||
.toBeLessThanOrEqual(1);
|
||||
await options.getByRole("checkbox", { name: "Semantic highlighting" }).scrollIntoViewIfNeeded();
|
||||
expect((await preview.boundingBox())!.y).toBeCloseTo(previewTop, 0);
|
||||
|
||||
const before = (await divider.boundingBox())!.y;
|
||||
await divider.press("ArrowUp");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeLessThan(before - 1);
|
||||
});
|
||||
@@ -4,7 +4,7 @@ for (const [id, selector] of [
|
||||
["general", "[class*='radios'] label"],
|
||||
["notifications", "table tbody td:first-child"],
|
||||
["keymap", "[class*='presetLabel']"],
|
||||
["editor.inspections", "[class*='profileControls'] > span:first-child"],
|
||||
["editor.inspections", "[class*='profileRow'] > span:first-child"],
|
||||
["vcs.issueNavigation", "[class*='pageBody'] button:not([aria-label])"],
|
||||
] as const) {
|
||||
test(`${id} keeps compact labels inside their controls`, async ({ workbench: page }) => {
|
||||
|
||||
@@ -1,51 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("the conflict actions stay visible beside or below the file list as the dialog resizes", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.evaluate(async () => {
|
||||
const storeModule = "/src/features/vcs/store.ts";
|
||||
const dialogModule = "/src/features/vcs/conflictsUi.tsx";
|
||||
const { useVcs } = await import(/* @vite-ignore */ storeModule);
|
||||
const { showConflictsDialog } = await import(/* @vite-ignore */ dialogModule);
|
||||
const root = "/dev/acme-api";
|
||||
useVcs.setState({
|
||||
root,
|
||||
status: Array.from({ length: 24 }, (_, index) => {
|
||||
const relPath = `services/payment-configuration/environments/env-${index + 1}.txt`;
|
||||
return { path: `${root}/${relPath}`, relPath, staged: null, unstaged: "conflicted", renamedFrom: null };
|
||||
}),
|
||||
});
|
||||
showConflictsDialog();
|
||||
});
|
||||
const dialog = page.getByRole("dialog", { name: "Conflicts", exact: true });
|
||||
const list = dialog.getByRole("listbox", { name: "Conflicted files" });
|
||||
const yours = dialog.getByRole("button", { name: "Accept Yours", exact: true });
|
||||
await expect(list).toBeFocused();
|
||||
const listBox = (await list.boundingBox())!;
|
||||
const first = (await yours.boundingBox())!;
|
||||
expect(first.x).toBeGreaterThan(listBox.x + listBox.width);
|
||||
expect(first.y).toBeLessThan(listBox.y + listBox.height / 2);
|
||||
|
||||
const grip = (await dialog.getByRole("separator", { name: "Resize", exact: true }).boundingBox())!;
|
||||
await page.mouse.move(grip.x + grip.width / 2, grip.y + grip.height / 2);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(grip.x + 36, grip.y + 68, { steps: 5 });
|
||||
await page.mouse.up();
|
||||
await expect.poll(async () => (await list.boundingBox())!.height).toBeGreaterThan(listBox.height + 40);
|
||||
|
||||
await page.setViewportSize({ width: 430, height: 530 });
|
||||
await expect(yours).toBeInViewport({ ratio: 1 });
|
||||
expect((await yours.boundingBox())!.y).toBeGreaterThan(
|
||||
(await list.boundingBox())!.y + (await list.boundingBox())!.height,
|
||||
);
|
||||
for (const name of ["Accept Theirs", "Merge…"])
|
||||
await expect(dialog.getByRole("button", { name, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.locator("[data-dialog-footer]").getByRole("button", { name: "Close" })).toBeInViewport({
|
||||
ratio: 1,
|
||||
});
|
||||
await list.press("End");
|
||||
await expect(list.getByRole("option", { selected: true })).toContainText("env-24.txt");
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -1,72 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Coverage keeps sortable statistics aligned next to the file tree at sidebar widths", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1050, height: 550 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
const projectModule = "/src/platform/project.ts";
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const layoutModule = "/src/workbench/toolwindows/store.ts";
|
||||
const { useProject } = await import(/* @vite-ignore */ projectModule);
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
const { setToolWindowSize } = await import(/* @vite-ignore */ layoutModule);
|
||||
const root = useProject.getState().project.root;
|
||||
const files = Array.from({ length: 36 }, (_, i) => ({
|
||||
path: root + (i === 0 ? "/src/Ready.ts" : i === 1 ? "/src/Uncovered.ts" : "/src/settlement/Report" + i + ".ts"),
|
||||
lines: [],
|
||||
linesCovered: i === 0 ? 20 : i,
|
||||
linesTotal: i === 0 ? 20 : 60,
|
||||
branchesCovered: i === 0 ? 4 : 1,
|
||||
branchesTotal: 4,
|
||||
}));
|
||||
window.__ipc.handlers.coverage_import = ({ path }) => ({
|
||||
runner: "lcov",
|
||||
hasBranches: path === "/tmp/coverage.lcov",
|
||||
files,
|
||||
});
|
||||
setToolWindowSize("right", 280);
|
||||
await executeAction("coverage.importReport", "/tmp/coverage.lcov");
|
||||
});
|
||||
|
||||
const coverage = page.getByRole("region", { name: "Coverage", exact: true });
|
||||
const tree = coverage.getByRole("tree", { name: "Coverage" });
|
||||
const line = coverage.getByRole("columnheader", { name: "Line, %" });
|
||||
const branch = coverage.getByRole("columnheader", { name: "Branch, %" });
|
||||
const folder = tree.getByRole("treeitem", { name: /^settlement/ });
|
||||
const ready = tree.getByRole("treeitem", { name: /^Ready\.ts/ });
|
||||
await expect(ready).toBeVisible();
|
||||
await expect(branch).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => tree.evaluate((element) => element.scrollWidth - element.clientWidth)).toBe(0);
|
||||
|
||||
const lineLeft = (await line.boundingBox())!.x;
|
||||
const branchLeft = (await branch.boundingBox())!.x;
|
||||
for (const row of [ready, folder]) {
|
||||
const cells = await row.getByTitle(/% \(/).all();
|
||||
expect(cells).toHaveLength(2);
|
||||
expect((await cells[0]!.boundingBox())!.x).toBeCloseTo(lineLeft, 0);
|
||||
expect((await cells[1]!.boundingBox())!.x).toBeCloseTo(branchLeft, 0);
|
||||
}
|
||||
|
||||
await branch.click();
|
||||
await expect(branch).toHaveAttribute("aria-sort", "descending");
|
||||
await expect(tree.getByRole("treeitem").nth(1)).toHaveAccessibleName(/^Ready\.ts/);
|
||||
await folder.locator("[data-tree-toggle]").click();
|
||||
const nested = tree.getByRole("treeitem", { name: /^Report/ }).first();
|
||||
await expect(nested).toBeVisible();
|
||||
expect(await tree.evaluate((element) => element.scrollHeight)).toBeGreaterThan(
|
||||
await tree.evaluate((element) => element.clientHeight),
|
||||
);
|
||||
expect((await nested.getByTitle("25% (1/4)").boundingBox())!.x).toBeCloseTo((await branch.boundingBox())!.x, 0);
|
||||
expect((await nested.getByTitle(/^Report/).boundingBox())!.width).toBeGreaterThan(30);
|
||||
|
||||
await page.evaluate(async () => {
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
await executeAction("coverage.importReport", "/tmp/lines.lcov");
|
||||
});
|
||||
await expect(branch).toHaveCount(0);
|
||||
await expect(line).toBeVisible();
|
||||
expect((await ready.getByTitle("100% (20/20)").boundingBox())!.x).toBeCloseTo((await line.boundingBox())!.x, 0);
|
||||
});
|
||||
@@ -1,75 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const functionName = "calculateRegionalSettlementFromExternalOrderBeforeReconciliation";
|
||||
const sourcePath = "/dev/acme-api/build.gradle.kts";
|
||||
|
||||
test("keeps frame sources and the keyboard selection visible in a narrow debug dock", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1120, height: 540 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ functionName, sourcePath }) => {
|
||||
const debugModule = "/src/features/debugger/state.ts";
|
||||
const layoutModule = "/src/workbench/toolwindows/store.ts";
|
||||
const servicesModule = "/src/workbench/contributions.ts";
|
||||
const { adoptSession } = await import(/* @vite-ignore */ debugModule);
|
||||
const { moveToolWindow, setToolWindowSize } = await import(/* @vite-ignore */ layoutModule);
|
||||
const { toolWindowService } = await import(/* @vite-ignore */ servicesModule);
|
||||
const workerFrame = {
|
||||
id: 51,
|
||||
name: "processOrder",
|
||||
path: sourcePath,
|
||||
line: 5,
|
||||
column: 0,
|
||||
presentationHint: null,
|
||||
};
|
||||
window.__ipc.handlers.debug_scopes = () => [];
|
||||
window.__ipc.handlers.debug_stack_trace = () => [workerFrame];
|
||||
adoptSession(91, {
|
||||
name: "Reconciliation",
|
||||
adapter: "debugpy",
|
||||
status: "paused",
|
||||
stoppedThread: 1,
|
||||
selectedThread: 1,
|
||||
threads: [
|
||||
{ id: 1, name: "MainThread" },
|
||||
{ id: 2, name: "Order worker" },
|
||||
],
|
||||
selectedFrame: 1,
|
||||
frames: Array.from({ length: 32 }, (_, index) => ({
|
||||
id: index + 1,
|
||||
name: index === 0 ? functionName : index === 1 ? "runBatch" : `reconcile(${index})`,
|
||||
path: sourcePath,
|
||||
line: index === 0 ? 41 : index,
|
||||
column: 0,
|
||||
presentationHint: null,
|
||||
})),
|
||||
});
|
||||
moveToolWindow("debug", "right");
|
||||
setToolWindowSize("right", 420);
|
||||
toolWindowService().show("debug", true);
|
||||
},
|
||||
{ functionName, sourcePath },
|
||||
);
|
||||
const debug = page.getByRole("region", { name: "Debug", exact: true });
|
||||
await debug.getByRole("tab", { name: "Threads & Variables", exact: true }).click();
|
||||
const thread = debug.getByRole("button", { name: "Thread", exact: true });
|
||||
const frames = debug.getByRole("listbox", { name: "Frames", exact: true });
|
||||
const first = frames.getByRole("option", { selected: true });
|
||||
await expect(first.getByText(functionName, { exact: true })).toBeVisible();
|
||||
expect(await frames.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(first.getByText(":42", { exact: true })).toBeInViewport({ ratio: 1 });
|
||||
expect(await first.getByText(/build\.gradle\.kts/).evaluate((el) => el.clientWidth)).toBeGreaterThan(25);
|
||||
const shortName = frames.getByText("runBatch", { exact: true });
|
||||
expect(await shortName.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await frames.focus();
|
||||
for (let i = 0; i < 25; i++) await page.keyboard.press("ArrowDown");
|
||||
const selected = frames.getByRole("option", { selected: true });
|
||||
await expect(selected.getByText("reconcile(25)", { exact: true })).toBeInViewport({ ratio: 0.95 });
|
||||
expect(await frames.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
|
||||
await thread.click();
|
||||
await page.getByRole("option", { name: "Order worker", exact: true }).click();
|
||||
await expect(thread).toContainText("Order worker");
|
||||
await expect(frames.getByRole("option", { selected: true })).toContainText("processOrder");
|
||||
});
|
||||
@@ -1,66 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("long diagnostics and quick fixes wrap within a narrow editor hover", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 580 });
|
||||
const path = "/dev/acme-api/Settlement.ts";
|
||||
const identifier = "QuarterlyCrossBorderSettlementProjection".repeat(4);
|
||||
const message = `Cannot resolve ${identifier}.\nCheck the settlement calculation.`;
|
||||
const title = `Replace with ${identifier}Result`;
|
||||
const range = { start: { line: 0, col: 0 }, end: { line: 0, col: 7 } };
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "pending();\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("pending()");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, message, title, range }) => {
|
||||
window.__ipc.handlers.lsp_hover = () => null;
|
||||
window.__ipc.handlers.lsp_code_actions = () => [
|
||||
{
|
||||
title,
|
||||
kind: "quickfix",
|
||||
isPreferred: true,
|
||||
disabledReason: null,
|
||||
edit: {
|
||||
files: [{ kind: "edit", path, edits: [{ range, new_text: "settled" }] }],
|
||||
},
|
||||
command: null,
|
||||
data: null,
|
||||
server: 1,
|
||||
},
|
||||
];
|
||||
const diagnostic = "/src/editor/lsp/diagnostics.ts";
|
||||
(await import(/* @vite-ignore */ diagnostic)).setFileDiagnostics(path, "settlement-lint", [
|
||||
{ severity: "error", message, range, source: "settlement-lint", code: "missing-model" },
|
||||
{ severity: "hint", message: "Review the reported total.", range, source: "settlement-lint", code: "review" },
|
||||
]);
|
||||
},
|
||||
{ path, message, title, range },
|
||||
);
|
||||
|
||||
await page.locator(".cm-content .cm-lintRange-error").hover();
|
||||
const hover = page.locator(".cm-lsp-hover");
|
||||
await expect(hover).toBeVisible();
|
||||
const fix = hover.getByRole("button", { name: new RegExp(`^${title}`) });
|
||||
await expect(fix).toBeVisible();
|
||||
expect(await hover.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
const messageText = hover.locator(".cm-lsp-diag-message").first();
|
||||
await expect(messageText).toHaveText(message);
|
||||
await expect(messageText).toHaveCSS("font-size", "13px");
|
||||
const shortcut = fix.locator(".cm-lsp-diag-shortcut");
|
||||
await expect(shortcut).toBeVisible();
|
||||
await expect(shortcut).toHaveCSS("font-size", "12px");
|
||||
const more = hover.getByRole("button", { name: "More actions…", exact: true }).first();
|
||||
await expect(more).toBeInViewport({ ratio: 1 });
|
||||
const outer = (await hover.boundingBox())!;
|
||||
const action = (await fix.boundingBox())!;
|
||||
const editor = (await page.locator(".cm-editor").boundingBox())!;
|
||||
expect(outer.x + outer.width).toBeLessThanOrEqual(editor.x + editor.width + 1);
|
||||
expect(action.x + action.width).toBeLessThanOrEqual(outer.x + outer.width);
|
||||
await more.click();
|
||||
const intentions = page.getByRole("dialog", { name: "Intentions", exact: true });
|
||||
await expect(intentions.getByRole("option", { name: title })).toBeVisible();
|
||||
});
|
||||
@@ -55,39 +55,6 @@ test("⌘F opens the find bar and highlights matches; Escape returns to the edit
|
||||
await expect(editor.locator(".cm-content")).toBeFocused();
|
||||
});
|
||||
|
||||
test("Go to Line keeps its label beside the selected coordinates and returns focus to the editor", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "build.gradle.kts");
|
||||
const content = editor.locator(".cm-content");
|
||||
await content.focus();
|
||||
await page.keyboard.press("Meta+l");
|
||||
const dialog = page.getByRole("dialog", { name: "Go to Line:Column", exact: true });
|
||||
const coordinates = dialog.getByRole("textbox", { name: "Line and column", exact: true });
|
||||
await expect(coordinates).toBeFocused();
|
||||
await expect(coordinates).toHaveValue("1:1");
|
||||
expect(await coordinates.evaluate((el: HTMLInputElement) => [el.selectionStart, el.selectionEnd])).toEqual([0, 3]);
|
||||
|
||||
await page.setViewportSize({ width: 360, height: 500 });
|
||||
const label = dialog.getByText("Line and column", { exact: true });
|
||||
await expect(label).toBeVisible();
|
||||
const text = (await label.boundingBox())!;
|
||||
const field = (await coordinates.boundingBox())!;
|
||||
expect(text.x + text.width).toBeLessThan(field.x);
|
||||
expect(Math.abs(text.y + text.height / 2 - field.y - field.height / 2)).toBeLessThan(2);
|
||||
await expect(coordinates).toHaveCSS("font-size", await label.evaluate((el) => getComputedStyle(el).fontSize));
|
||||
|
||||
await coordinates.fill("0:2");
|
||||
await expect(coordinates).toHaveAttribute("aria-invalid", "true");
|
||||
await expect(dialog.getByRole("button", { name: "OK", exact: true })).toBeDisabled();
|
||||
await coordinates.fill("6:8");
|
||||
await coordinates.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
await page.setViewportSize({ width: 960, height: 600 });
|
||||
await expect(page.getByRole("button", { name: "6:8", exact: true })).toBeVisible();
|
||||
});
|
||||
|
||||
test("each file keeps its own find bar, query and caret", async ({ workbench: page }) => {
|
||||
const find = page.getByRole("textbox", { name: "Find" });
|
||||
const caret = page.getByRole("button", { name: /^\d+:\d+/ });
|
||||
@@ -406,48 +373,6 @@ test("Markdown preview highlights ⌘F matches, selected words and scales diagra
|
||||
expect(reset.excalidraw).toBeCloseTo(base.excalidraw, 1);
|
||||
});
|
||||
|
||||
test("Markdown preview keeps following find and edits after scrolling the source", async ({ workbench: page }) => {
|
||||
const editor = await openFromTree(page, "README.md");
|
||||
const content = editor.locator(".cm-content");
|
||||
const preview = page.getByRole("document", { name: "Markdown preview" });
|
||||
await content.click();
|
||||
await page.keyboard.press("Meta+a");
|
||||
const spacer = Array.from({ length: 90 }, (_, i) => `Paragraph ${i}.`).join("\n\n");
|
||||
await page.keyboard.insertText(`First needle\n\n${spacer}\n\nSecond needle\n\n${spacer}\n\nThird needle`);
|
||||
await content.press("Control+Home");
|
||||
await expect(preview).toContainText("Third needle");
|
||||
await editor.locator(".cm-scroller").evaluate((el) => (el.scrollTop = 2000));
|
||||
await expect.poll(() => preview.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
|
||||
await preview.focus();
|
||||
await page.keyboard.press("Meta+f");
|
||||
const find = page.getByRole("textbox", { name: "Find" });
|
||||
await find.fill("needle");
|
||||
const visibleMatch = () =>
|
||||
preview.evaluate((el) => {
|
||||
const match = (CSS.highlights.get("markdown-find-current") as unknown as Set<Range> | undefined)
|
||||
?.values()
|
||||
.next().value;
|
||||
if (!match) return null;
|
||||
const box = el.getBoundingClientRect();
|
||||
const range = match.getBoundingClientRect();
|
||||
return range.top >= box.top && range.bottom <= box.bottom ? match.startContainer.textContent : null;
|
||||
});
|
||||
await expect.poll(visibleMatch).toBe("First needle");
|
||||
await find.press("ArrowDown");
|
||||
await expect.poll(visibleMatch).toBe("Second needle");
|
||||
await find.press("ArrowDown");
|
||||
await expect.poll(visibleMatch).toBe("Third needle");
|
||||
await find.press("ArrowUp");
|
||||
await expect.poll(visibleMatch).toBe("Second needle");
|
||||
|
||||
await find.press("Escape");
|
||||
await content.focus();
|
||||
await page.keyboard.press("Meta+a");
|
||||
await page.keyboard.insertText("- **$`v_0`$ Flat wings.**");
|
||||
await expect(preview.locator("strong .katex annotation")).toHaveText("v_0");
|
||||
});
|
||||
|
||||
test("Markdown preview aligns Mermaid diagrams to their container align attribute", async ({ workbench: page }) => {
|
||||
const editor = await openFromTree(page, "README.md");
|
||||
const content = editor.locator(".cm-content");
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("Editor Font keeps the preview in view while editing and resizing the controls", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1200, height: 760 });
|
||||
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("Show only monospaced fonts");
|
||||
await settings.getByRole("treeitem", { name: "Font", exact: true, level: 2 }).click();
|
||||
await search.clear();
|
||||
|
||||
const divider = settings.getByRole("separator", { name: "Resize font preview" });
|
||||
const options = settings.getByRole("region", { name: "Font options", exact: true });
|
||||
const preview = settings.getByRole("textbox", { name: "Font preview", exact: true });
|
||||
const font = options.getByRole("combobox", { name: "Font", exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "vertical");
|
||||
expect((await font.boundingBox())!.x).toBeLessThan((await preview.boundingBox())!.x);
|
||||
await expect.poll(() => preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await preview.fill("function main() { return 42; }");
|
||||
await options.getByRole("textbox", { name: "Size", exact: true }).fill("18");
|
||||
await options.getByRole("textbox", { name: "Line height", exact: true }).fill("25");
|
||||
await expect(preview).toHaveCSS("font-size", "18px");
|
||||
await expect(preview).toHaveCSS("line-height", "25px");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 620 });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
expect((await font.boundingBox())!.y).toBeLessThan((await preview.boundingBox())!.y);
|
||||
await expect(preview).toHaveValue("function main() { return 42; }");
|
||||
const y = (await divider.boundingBox())!.y;
|
||||
await divider.press("ArrowDown");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeGreaterThan(y + 1);
|
||||
|
||||
await search.fill("Fallback font");
|
||||
const fallback = options.getByRole("combobox", { name: "Fallback font", exact: true });
|
||||
await fallback.scrollIntoViewIfNeeded();
|
||||
await expect(fallback).toBeInViewport();
|
||||
await fallback.fill("Consolas");
|
||||
await expect(preview).toHaveCSS("font-family", /Consolas/);
|
||||
await expect(preview).toBeInViewport();
|
||||
await expect.poll(() => options.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
});
|
||||
@@ -64,15 +64,3 @@ test("editor Git submenu keeps repository actions disabled without Git", async (
|
||||
}
|
||||
await expect(page.getByRole("menuitem", { name: "Clone…", exact: true })).toBeEnabled();
|
||||
});
|
||||
|
||||
test("Project view Git submenu ends with Manage Remotes and Clone", async ({ workbench: page }) => {
|
||||
await page.getByRole("treeitem", { name: /README\.md/ }).click({ button: "right" });
|
||||
await page.getByRole("menuitem", { name: "Git", exact: true }).hover();
|
||||
const git = page.getByRole("menu").filter({ has: page.getByRole("menuitem", { name: "Clone…", exact: true }) });
|
||||
const items = git.locator('[role="menuitem"], [role="menuitemcheckbox"]');
|
||||
await expect(items.nth(-3)).toHaveText(/Unstash Changes…/);
|
||||
await expect(items.nth(-2)).toHaveText(/Manage Remotes…/);
|
||||
await expect(items.nth(-1)).toHaveText(/Clone…/);
|
||||
await git.getByRole("menuitem", { name: "Manage Remotes…", exact: true }).click();
|
||||
await expect(page.getByRole("dialog", { name: "Git Remotes" })).toBeVisible();
|
||||
});
|
||||
@@ -1,65 +0,0 @@
|
||||
import type { ExtractInterfaceInfo } from "../src/bindings";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const info: ExtractInterfaceInfo = {
|
||||
className: "InvoiceService",
|
||||
packages: [
|
||||
{ displayName: "com.example.billing", path: "/dev/acme-api", isParentOfSelectedFile: true },
|
||||
{ displayName: "com.example.billing.api", path: "/dev/acme-api/api" },
|
||||
].map((entry) => JSON.stringify(entry)),
|
||||
members: Array.from({ length: 24 }, (_, i) => ({
|
||||
name: `prepareInvoiceForInternationalSettlement${i + 1}`,
|
||||
parameters: ["BigDecimal", "Map<String, BigDecimal>", "LocalDate", "boolean"],
|
||||
typeName: "SettlementInvoice",
|
||||
handleIdentifier: `method-${i + 1}`,
|
||||
})),
|
||||
};
|
||||
|
||||
test("keeps the interface fields, members and actions usable in a short window", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 470, height: 410 });
|
||||
await page.evaluate(async () => {
|
||||
const workbench = "/src/workbench/contributions.ts";
|
||||
const { editorService } = await import(/* @vite-ignore */ workbench);
|
||||
await editorService().openFile("/dev/acme-api/InvoiceService.java", { focus: true });
|
||||
});
|
||||
const editor = page.locator(".cm-editor .cm-content");
|
||||
await expect(editor).toBeVisible();
|
||||
await stubDesktop(page);
|
||||
await editor.focus();
|
||||
await page.evaluate(async (info) => {
|
||||
window.__ipc.handlers.lsp_extract_interface_info = () => info;
|
||||
const actions = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actions);
|
||||
await executeAction("refactor.extractInterface");
|
||||
}, info);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Extract Interface" });
|
||||
const table = dialog.getByRole("table", { name: "Members to Form Interface" });
|
||||
await expect(table.getByRole("row")).toHaveCount(25);
|
||||
const source = dialog.getByRole("textbox", { name: "Extract interface from:", exact: true });
|
||||
const name = dialog.getByRole("textbox", { name: "Interface name:", exact: true });
|
||||
await expect(source).toHaveAttribute("readonly", "");
|
||||
await expect(source).toHaveValue("InvoiceService");
|
||||
await expect(name).toBeFocused();
|
||||
await expect(source).toBeInViewport({ ratio: 1 });
|
||||
await name.fill("SettlementInvoicing");
|
||||
|
||||
const body = dialog.locator("[data-dialog-body]");
|
||||
const refactor = dialog.getByRole("button", { name: "Refactor", exact: true });
|
||||
await expect(refactor).toBeDisabled();
|
||||
const last = table.getByRole("checkbox", { name: /^prepareInvoiceForInternationalSettlement24\(/ });
|
||||
await last.scrollIntoViewIfNeeded();
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(table.getByRole("columnheader", { name: "Member" })).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => table.evaluate((el) => el.scrollTop)).toBeGreaterThan(100);
|
||||
expect(await table.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await last.check();
|
||||
await expect(refactor).toBeEnabled();
|
||||
expect(await body.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1);
|
||||
await expect(refactor).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.getByRole("button", { name: "Preview", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect(editor).toBeFocused();
|
||||
});
|
||||
@@ -1,62 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("File Types keeps association editors usable and opens ignored rules from search", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(settings).toBeVisible();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.languages = () => [
|
||||
{ id: "javascript", name: "JavaScript", extensions: ["js"] },
|
||||
{ id: "python", name: "Python", extensions: ["py", "pyi", "pyw"], filenames: ["SConstruct", "SConscript"] },
|
||||
];
|
||||
});
|
||||
const search = settings.getByRole("textbox", { name: "Search settings" });
|
||||
await search.fill("File Types");
|
||||
await settings.getByRole("treeitem", { name: "File Types", exact: true }).click();
|
||||
await search.clear();
|
||||
|
||||
const tabs = settings.getByRole("tablist", { name: "File Types" });
|
||||
const recognized = tabs.getByRole("tab", { name: "Recognized File Types" });
|
||||
const ignored = tabs.getByRole("tab", { name: "Ignored Files and Folders" });
|
||||
await expect(recognized).toHaveAttribute("aria-selected", "true");
|
||||
const divider = settings.getByRole("separator", { name: "Resize file type panes" });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "vertical");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 660 });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
const types = settings.getByRole("listbox", { name: "Recognized file types", exact: true });
|
||||
await types.getByRole("option", { name: "Python", exact: true }).click();
|
||||
const patterns = settings.getByRole("listbox", { name: "File name patterns of Python" });
|
||||
const hashbangLabel = settings.getByText("Hashbang patterns", { exact: true });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const nameList = await patterns.boundingBox();
|
||||
const hashbangHeading = await hashbangLabel.boundingBox();
|
||||
return nameList && hashbangHeading ? hashbangHeading.y - (nameList.y + nameList.height) : -1;
|
||||
})
|
||||
.toBeGreaterThan(0);
|
||||
await expect
|
||||
.poll(() => settings.locator("[class*='_patterns_']").evaluate((el) => el.scrollWidth - el.clientWidth))
|
||||
.toBeLessThanOrEqual(1);
|
||||
const toolbar = settings.locator(`[role="toolbar"][aria-controls="${await patterns.getAttribute("id")}"]`);
|
||||
await toolbar.getByRole("button", { name: "Add" }).click();
|
||||
const pattern = patterns.getByRole("textbox", { name: "Pattern" });
|
||||
await pattern.fill("*.layout-demo");
|
||||
await pattern.press("Enter");
|
||||
await expect(patterns.getByRole("option", { name: "*.layout-demo", exact: true })).toBeVisible();
|
||||
await expect
|
||||
.poll(() => settings.locator("[class*='pageBody']").evaluate((el) => el.scrollWidth - el.clientWidth))
|
||||
.toBeLessThanOrEqual(1);
|
||||
|
||||
await search.fill("Exclude patterns");
|
||||
await expect(ignored).toHaveAttribute("aria-selected", "true");
|
||||
await expect(settings.getByRole("listbox", { name: "Exclude patterns" })).toBeVisible();
|
||||
await expect(patterns).toBeHidden();
|
||||
await ignored.click();
|
||||
await search.clear();
|
||||
await ignored.press("ArrowLeft");
|
||||
await expect(recognized).toHaveAttribute("aria-selected", "true");
|
||||
await expect(patterns.getByRole("option", { name: "*.layout-demo", exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -1,68 +0,0 @@
|
||||
import type { Remote, RemoteEdit } from "../src/bindings";
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("keeps remote columns, actions and editing usable in a short window", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 450, height: 420 });
|
||||
await stubDesktop(page);
|
||||
const originalUrl = "https://git.example.test/engineering/international-settlement/replica-18.git";
|
||||
await page.evaluate(async (originalUrl) => {
|
||||
let remotes: Remote[] = Array.from({ length: 18 }, (_, i) => ({
|
||||
name: i === 0 ? "origin" : `mirror-${i + 1}`,
|
||||
url: i === 17 ? originalUrl : `https://git.example.test/project/repository-${i + 1}.git`,
|
||||
}));
|
||||
window.__ipc.handlers.vcs_remotes = () => remotes;
|
||||
window.__ipc.handlers.vcs_edit_remote = ({ edit }) => {
|
||||
const patch = edit as RemoteEdit;
|
||||
if (patch.op === "edit") {
|
||||
remotes = remotes.map((remote) =>
|
||||
remote.name === patch.name ? { name: patch.new_name, url: patch.url } : remote,
|
||||
);
|
||||
}
|
||||
return null;
|
||||
};
|
||||
window.__ipc.handlers.vcs_branches = () => [];
|
||||
const module = "/src/features/vcs/gitMenuDialogs.tsx";
|
||||
const { showManageRemotes } = await import(/* @vite-ignore */ module);
|
||||
showManageRemotes();
|
||||
}, originalUrl);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Git Remotes", exact: true });
|
||||
await expect(dialog.getByText(originalUrl, { exact: true })).toBeVisible();
|
||||
const table = dialog.getByRole("grid", { name: "Remotes", exact: true });
|
||||
const name = table.getByRole("columnheader", { name: "Name", exact: true });
|
||||
const url = table.getByRole("columnheader", { name: "URL", exact: true });
|
||||
await expect(name).toBeInViewport({ ratio: 1 });
|
||||
await expect(url).toBeInViewport({ ratio: 1 });
|
||||
const first = table.getByRole("row", { name: /^origin / });
|
||||
const last = table.getByRole("row", { name: /^mirror-18 / });
|
||||
await first.click();
|
||||
await page.keyboard.press("End");
|
||||
await expect(last).toBeFocused();
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(url).toBeInViewport({ ratio: 1 });
|
||||
const cell = last.getByRole("gridcell", { name: originalUrl, exact: true });
|
||||
await expect(cell).toHaveAttribute("title", originalUrl);
|
||||
expect((await cell.boundingBox())!.x).toBeCloseTo((await url.boundingBox())!.x, 0);
|
||||
const scroller = table.locator("..");
|
||||
expect(await scroller.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
expect(await scroller.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(dialog.getByRole("button", { name: "Add Remote…" })).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.getByRole("button", { name: "OK", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.keyboard.press("Enter");
|
||||
const edit = page.getByRole("dialog", { name: "Edit Remote", exact: true });
|
||||
const editName = edit.getByRole("textbox", { name: "Name", exact: true });
|
||||
const editUrl = edit.getByRole("textbox", { name: "URL", exact: true });
|
||||
await expect(editName).toHaveValue("mirror-18");
|
||||
await expect(editUrl).toHaveValue(originalUrl);
|
||||
expect((await editName.boundingBox())!.x).toBeCloseTo((await editUrl.boundingBox())!.x, 0);
|
||||
const nextUrl = "https://git.example.test/repository-18.git";
|
||||
await editUrl.fill(nextUrl);
|
||||
await edit.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await expect(last).toContainText(nextUrl);
|
||||
await expect(last).toBeFocused();
|
||||
expect(await ipcCalls(page, "vcs_edit_remote")).toMatchObject([
|
||||
{ edit: { op: "edit", name: "mirror-18", new_name: "mirror-18", url: nextUrl } },
|
||||
]);
|
||||
});
|
||||
@@ -1,75 +0,0 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("an inline change keeps its actions and original code readable at the editor zoom", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 445, height: 520 });
|
||||
await stubDesktop(page);
|
||||
const original = "const routingPolicy = 'use the legacy regional settlement cutoff before reconciliation';";
|
||||
const current = "const routingPolicy = 'use the current policy';";
|
||||
const content = Array.from({ length: 22 }, (_, i) => {
|
||||
if (i === 4) return current;
|
||||
if (i === 11) return "const settlementWindow = 12;";
|
||||
return `// context ${i + 1}`;
|
||||
}).join("\n");
|
||||
|
||||
await page.evaluate(async (text) => {
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
window.__ipc.handlers.fs_probe = () => ({ size: text.length, binary: false, tooLarge: false });
|
||||
window.__ipc.handlers.fs_read_text = () => text;
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile("/dev/acme-api/settlement.ts");
|
||||
}, content);
|
||||
const editor = page.locator(".cm-editor");
|
||||
await expect(editor.locator(".cm-content")).toBeVisible();
|
||||
|
||||
await editor.evaluate(
|
||||
async (el, { original, content }) => {
|
||||
const { view } = (el.querySelector(".cm-content") as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dom.style.setProperty("--openidea-editor-font-size", "18px");
|
||||
view.dispatch({ changes: { from: 0, to: view.state.doc.length, insert: content }, selection: { anchor: 0 } });
|
||||
window.__ipc.handlers.vcs_line_hunks = () => [
|
||||
{ kind: "modified", start: 4, lines: 1, oldStart: 4, oldLines: 1, oldText: original + "\n" },
|
||||
{ kind: "added", start: 11, lines: 1, oldStart: 11, oldLines: 0, oldText: "" },
|
||||
{ kind: "deleted", start: 15, lines: 0, oldStart: 14, oldLines: 1, oldText: "// obsolete window\n" },
|
||||
];
|
||||
const storeModule = "/src/features/vcs/store.ts";
|
||||
const { useVcs } = await import(/* @vite-ignore */ storeModule);
|
||||
useVcs.setState({ available: true, version: useVcs.getState().version + 1 });
|
||||
},
|
||||
{ original, content },
|
||||
);
|
||||
await editor.getByTitle("Modified lines (click to show)", { exact: true }).click();
|
||||
const modified = page.getByRole("dialog", { name: "Modified lines" });
|
||||
await expect(modified).toBeVisible();
|
||||
const originalText = modified.getByText(original, { exact: false });
|
||||
await expect(originalText).toHaveCSS("font-size", "18px");
|
||||
await expect(modified.getByText(current, { exact: false })).toHaveCount(0);
|
||||
await expect(editor.getByText(current, { exact: true })).toBeVisible();
|
||||
|
||||
const preview = modified.getByRole("region", { name: "Original text" });
|
||||
await expect(preview.locator(".tok-keyword")).toHaveText("const");
|
||||
const toolbar = modified.getByRole("toolbar", { name: "Change actions" });
|
||||
expect(await preview.evaluate((el) => el.scrollWidth > el.clientWidth)).toBe(true);
|
||||
const previewBox = (await preview.boundingBox())!;
|
||||
const toolbarBox = (await toolbar.boundingBox())!;
|
||||
const currentBox = (await editor.getByText(current, { exact: true }).boundingBox())!;
|
||||
expect(previewBox.y).toBeGreaterThanOrEqual(toolbarBox.y + toolbarBox.height - 1);
|
||||
expect(
|
||||
toolbarBox.y >= currentBox.y + currentBox.height - 1 || previewBox.y + previewBox.height <= currentBox.y + 1,
|
||||
).toBe(true);
|
||||
expect(previewBox.x).toBeGreaterThanOrEqual(0);
|
||||
expect(previewBox.x + previewBox.width).toBeLessThanOrEqual(445);
|
||||
await toolbar.getByRole("button", { name: "Next Change" }).click();
|
||||
const added = page.getByRole("dialog", { name: "Added lines" });
|
||||
await expect(added).toBeVisible();
|
||||
await expect(added.getByRole("region", { name: "Original text" })).toHaveCount(0);
|
||||
await expect(added.getByRole("button", { name: "Copy Original Text" })).toBeDisabled();
|
||||
|
||||
await added.getByRole("button", { name: "Next Change" }).click();
|
||||
const deleted = page.getByRole("dialog", { name: "Deleted lines" });
|
||||
await expect(deleted.getByRole("region", { name: "Original text" })).toHaveText("// obsolete window");
|
||||
await deleted.getByRole("button", { name: "Rollback" }).click();
|
||||
await expect(deleted).toBeHidden();
|
||||
await expect(editor.getByText("// obsolete window", { exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -1,37 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("gutter icon previews align in narrow settings and the master switch keeps each choice", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("textbox", { name: "Search settings" }).fill("Color preview");
|
||||
await settings.getByRole("treeitem", { name: "Gutter Icons", exact: true }).click();
|
||||
await page.setViewportSize({ width: 520, height: 620 });
|
||||
|
||||
const list = settings.getByRole("list", { name: "Gutter Icons", exact: true });
|
||||
await expect(list.getByRole("listitem")).toHaveCount(5);
|
||||
await expect(list.locator("mark")).toHaveText(["Color", "preview"]);
|
||||
const layout = await list.getByRole("listitem").evaluateAll((rows) =>
|
||||
rows.map((row) => {
|
||||
const preview = row.firstElementChild!.getBoundingClientRect();
|
||||
const input = row.querySelector("input")!.getBoundingClientRect();
|
||||
return { x: input.x, previewRight: preview.right, overflow: row.scrollWidth - row.clientWidth };
|
||||
}),
|
||||
);
|
||||
for (const row of layout) {
|
||||
expect(row.previewRight).toBeLessThan(row.x);
|
||||
expect(row.x).toBeCloseTo(layout[0]!.x, 0);
|
||||
expect(row.overflow).toBeLessThanOrEqual(1);
|
||||
}
|
||||
|
||||
const master = settings.getByRole("checkbox", { name: "Show gutter icons", exact: true });
|
||||
const color = list.getByRole("checkbox", { name: "Color preview", exact: true });
|
||||
await color.uncheck();
|
||||
await master.uncheck();
|
||||
for (const option of await list.getByRole("checkbox").all()) await expect(option).toBeDisabled();
|
||||
await master.check();
|
||||
await expect(color).toBeEnabled();
|
||||
await expect(color).not.toBeChecked();
|
||||
await expect(list.getByRole("checkbox", { name: "Bookmarks", exact: true })).toBeChecked();
|
||||
});
|
||||
@@ -1,89 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("inspection results keep source context and actions visible as the dock narrows", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1100, height: 720 });
|
||||
const relative = "modules/settlement/reconciliation/QuarterlySettlementReconciliationCoordinator.ts";
|
||||
const path = `/dev/acme-api/${relative}`;
|
||||
const title = "The estimated settlement total ignores the currency conversion for pending merchant payments";
|
||||
const detail = "Check the calculation before saving the reconciliation report.";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend))
|
||||
.docBackend()
|
||||
.files.set(path, "const amount = 100;\nconst exchangeRate = 3;\nconst estimate = amount;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("estimate");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, relative, title, detail }) => {
|
||||
window.__ipc.handlers.inspect_code = ({ onEvent }) => {
|
||||
window.__ipc.send(onEvent, { type: "started", total: 1 });
|
||||
window.__ipc.send(onEvent, {
|
||||
type: "file",
|
||||
done: 1,
|
||||
file: {
|
||||
path,
|
||||
relPath: relative,
|
||||
diagnostics: [
|
||||
{
|
||||
range: { start: { line: 2, col: 6 }, end: { line: 2, col: 14 } },
|
||||
severity: "warning",
|
||||
message: `${title}\n${detail}`,
|
||||
source: "lint",
|
||||
code: "pending-currency-conversion",
|
||||
},
|
||||
],
|
||||
},
|
||||
});
|
||||
window.__ipc.send(onEvent, {
|
||||
type: "done",
|
||||
summary: { files: 1, problems: 1, skipped: 0, failed: 0, cancelled: false, elapsedMs: 30 },
|
||||
});
|
||||
};
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("analyze.inspectFile");
|
||||
},
|
||||
{ path, relative, title, detail },
|
||||
);
|
||||
|
||||
const tree = page.getByRole("tree", { name: "Inspection results" });
|
||||
const problem = tree.getByRole("treeitem").filter({ hasText: title });
|
||||
await problem.click({ position: { x: 95, y: 12 } });
|
||||
const jump = page.getByRole("button", { name: "Jump to Source" });
|
||||
const message = page.getByText(detail, { exact: false }).filter({ visible: true }).last();
|
||||
expect((await jump.boundingBox())!.y).toBeLessThan((await message.boundingBox())!.y);
|
||||
const details = page.getByRole("region", { name: "Inspection details" });
|
||||
const quickFixes = details.getByRole("button", { name: "Show Quick Fixes" });
|
||||
await expect(details.getByText(`${relative}:3:7`)).toBeVisible();
|
||||
const split = page.getByRole("separator", { name: "Resize inspection panes" });
|
||||
await expect(split).toHaveAttribute("aria-valuenow", "50");
|
||||
await split.focus();
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(split).not.toHaveAttribute("aria-valuenow", "50");
|
||||
|
||||
await page.setViewportSize({ width: 540, height: 680 });
|
||||
await expect(quickFixes).toBeInViewport({ ratio: 1 });
|
||||
await expect(jump).toBeInViewport({ ratio: 1 });
|
||||
const right = (await details.boundingBox())!;
|
||||
const jumpBounds = (await jump.boundingBox())!;
|
||||
expect(jumpBounds.x + jumpBounds.width).toBeLessThan(right.x + right.width);
|
||||
const file = tree.getByRole("treeitem").filter({ has: page.getByTitle(relative, { exact: true }) });
|
||||
const count = file.getByText("1", { exact: true });
|
||||
const fileBounds = (await file.boundingBox())!;
|
||||
const countBounds = (await count.boundingBox())!;
|
||||
expect(countBounds.x + countBounds.width).toBeLessThan(fileBounds.x + fileBounds.width);
|
||||
expect(await message.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
expect(await tree.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await jump.click();
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(async () => {
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
const cursor = (await import(/* @vite-ignore */ service)).editorService().activeCursor();
|
||||
return { path: cursor?.path, line: cursor?.line, col: cursor?.col };
|
||||
}),
|
||||
)
|
||||
.toEqual({ path, line: 2, col: 6 });
|
||||
});
|
||||
@@ -1,59 +0,0 @@
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("keyboard navigation reveals items in a short Git submenu", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 650, height: 390 });
|
||||
const editor = await openFromTree(page, "README.md");
|
||||
await editor.locator(".cm-content").click({ button: "right" });
|
||||
await page.getByRole("menuitem", { name: "Git", exact: true }).hover();
|
||||
const last = page.getByRole("menuitem", { name: "Clone…", exact: true });
|
||||
const popup = last.locator("xpath=ancestor::*[@data-popup][1]");
|
||||
const first = popup.locator('[role="menuitem"]:not([aria-disabled="true"])').first();
|
||||
await expect(popup).toHaveAttribute("data-positioned", "true");
|
||||
await expect(first).toBeFocused();
|
||||
expect(await popup.evaluate((el) => el.scrollHeight)).toBeGreaterThan(await popup.evaluate((el) => el.clientHeight));
|
||||
|
||||
await page.keyboard.press("End");
|
||||
await expect(last).toBeFocused();
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => popup.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
|
||||
const scroll = await popup.evaluate((el) => el.scrollTop);
|
||||
await popup.evaluate((el) => (el.scrollTop = 0));
|
||||
await page.keyboard.press("End");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => popup.evaluate((el) => el.scrollTop)).toBe(scroll);
|
||||
|
||||
await page.keyboard.press("Home");
|
||||
await expect(first).toBeFocused();
|
||||
await expect(first).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => popup.evaluate((el) => el.scrollTop)).toBeLessThan(scroll);
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
await expect(last).toBeHidden();
|
||||
await expect(page.getByRole("menuitem", { name: "Git", exact: true })).toBeFocused();
|
||||
});
|
||||
|
||||
test("shortcut ends align on a menu level with submenus", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 390, height: 480 });
|
||||
const chord = "Ctrl+Shift+Meta+K, Ctrl+Shift+Meta+B, Ctrl+Shift+Meta+M";
|
||||
await page.evaluate(async (chord) => {
|
||||
const path = "/src/ui/Menu.tsx";
|
||||
const { showContextMenu } = await import(/* @vite-ignore */ path);
|
||||
showContextMenu({ x: 80, y: 80 }, [
|
||||
{ label: "Open", shortcut: "Ctrl+O" },
|
||||
{ label: "Open Recent", shortcut: "Ctrl+Shift+O", submenu: [{ label: "Payments service" }] },
|
||||
{ label: "Open File in a New Window", shortcut: chord },
|
||||
]);
|
||||
}, chord);
|
||||
const menu = page.getByRole("menu", { name: "Context menu" });
|
||||
const first = menu.getByText("Ctrl+O", { exact: true });
|
||||
const second = menu.getByText("Ctrl+Shift+O", { exact: true });
|
||||
await expect(first).toBeVisible();
|
||||
await expect(second).toBeVisible();
|
||||
const a = (await first.boundingBox())!;
|
||||
const b = (await second.boundingBox())!;
|
||||
expect(a.x + a.width).toBeCloseTo(b.x + b.width, 0);
|
||||
const long = menu.getByText(chord, { exact: true });
|
||||
await expect(long).toHaveAttribute("title", chord);
|
||||
expect(await long.evaluate((el) => el.scrollWidth)).toBeGreaterThan(await long.evaluate((el) => el.clientWidth));
|
||||
await expect(menu.getByText("Open File in a New Window", { exact: true })).toBeInViewport({ ratio: 1 });
|
||||
});
|
||||
@@ -1,138 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("the floating navigation list stays beside the visible segment and scrolls to keyboard selection", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 600, height: 560 });
|
||||
const folder = "billing";
|
||||
const parent =
|
||||
"/dev/acme-api/quarterly-settlement-and-reconciliation/merchant-accounts-with-exchange-rate-adjustments";
|
||||
const directory = `${parent}/${folder}`;
|
||||
const filename = "SettlementSummary.ts";
|
||||
const path = `${directory}/${filename}`;
|
||||
const long = "QuarterlyReconciliationForPendingSettlementAndCrossBorderMerchantAdjustments.ts";
|
||||
const last = "YearEndTotals.ts";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "export const pending = 1;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("pending");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ directory, filename, long, last }) => {
|
||||
window.__ipc.handlers.fs_read_dir = ({ path }) =>
|
||||
path === directory
|
||||
? ["archive", long, ...Array.from({ length: 24 }, (_, i) => `Report-${i + 1}.ts`), filename, last].map(
|
||||
(name) => ({
|
||||
name,
|
||||
path: `${directory}/${name}`,
|
||||
kind: name === "archive" ? "dir" : "file",
|
||||
size: name === "archive" ? 0 : 1,
|
||||
}),
|
||||
)
|
||||
: [];
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("navigate.navigationBar");
|
||||
},
|
||||
{ directory, filename, long, last },
|
||||
);
|
||||
const bar = page.getByRole("toolbar", { name: "Navigation bar" });
|
||||
await expect(bar).toBeVisible();
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
const segment = bar.getByRole("button", { name: folder, exact: true });
|
||||
await expect(segment).toHaveAttribute("aria-current", "location");
|
||||
const barBounds = (await bar.boundingBox())!;
|
||||
await page.keyboard.press("ArrowDown");
|
||||
const list = page.getByRole("listbox", { name: "Children" });
|
||||
await expect(list).toBeVisible();
|
||||
await expect(list.getByRole("option", { name: filename, exact: true })).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await list.boundingBox())!;
|
||||
return bounds.x >= 5 && bounds.x + bounds.width <= 595;
|
||||
})
|
||||
.toBe(true);
|
||||
expect((await list.boundingBox())!.y).toBeGreaterThanOrEqual(barBounds.y + barBounds.height - 4);
|
||||
expect((await bar.boundingBox())!.height).toBeCloseTo(barBounds.height);
|
||||
|
||||
await page.keyboard.press("Home");
|
||||
const folderRow = list.getByRole("option", { name: "archive" });
|
||||
await expect(folderRow).toHaveAttribute("aria-selected", "true");
|
||||
await expect(folderRow).toBeInViewport({ ratio: 1 });
|
||||
await expect(list.getByRole("option", { name: long, exact: true }).getByTitle(long)).toBeVisible();
|
||||
expect(await list.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await page.keyboard.press("End");
|
||||
const lastRow = list.getByRole("option", { name: last, exact: true });
|
||||
await expect(lastRow).toHaveAttribute("aria-selected", "true");
|
||||
await expect(lastRow).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(list).toBeHidden();
|
||||
await expect(bar).toBeFocused();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(bar).toBeHidden();
|
||||
});
|
||||
|
||||
for (const position of ["top", "statusBar"] as const) {
|
||||
test(`the ${position} navigation list opens toward the editor and keeps folder navigation`, async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const directory = "/dev/acme-api/src";
|
||||
const path = `${directory}/Overview.ts`;
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "export const overview = 1;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("overview");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ directory, position }) => {
|
||||
const archive = `${directory}/archive`;
|
||||
window.__ipc.handlers.fs_read_dir = ({ path }) =>
|
||||
path === directory
|
||||
? [
|
||||
{ path: archive, name: "archive", kind: "dir", size: 0 },
|
||||
{ path: `${directory}/Overview.ts`, name: "Overview.ts", kind: "file", size: 1 },
|
||||
]
|
||||
: path === archive
|
||||
? [{ path: `${archive}/Previous.ts`, name: "Previous.ts", kind: "file", size: 1 }]
|
||||
: [];
|
||||
const source = await (await fetch("/src/workbench/Workbench.tsx")).text();
|
||||
const project = source.match(/["'](\/src\/platform\/project\.ts(?:\?[^"']+)?)["']/)?.[1];
|
||||
if (!project) throw new Error("Missing project store");
|
||||
const { useProject } = await import(/* @vite-ignore */ project);
|
||||
const settings = useProject.getState().settings;
|
||||
useProject.setState({
|
||||
settings: { ...settings, appearance: { ...settings?.appearance, navigationBar: position } },
|
||||
});
|
||||
},
|
||||
{ directory, position },
|
||||
);
|
||||
const anchor = page
|
||||
.getByRole("navigation", { name: "Breadcrumbs" })
|
||||
.getByRole("button", { name: "src", exact: true });
|
||||
await anchor.click();
|
||||
const list = page.getByRole("listbox", { name: "src", exact: true });
|
||||
const archive = list.getByRole("option", { name: "archive" });
|
||||
await expect(archive).toHaveAttribute("aria-selected", "true");
|
||||
await expect(list).toBeFocused();
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await anchor.boundingBox())!;
|
||||
const popup = (await list.boundingBox())!;
|
||||
return position === "top" ? popup.y >= bounds.y + bounds.height : popup.y + popup.height <= bounds.y;
|
||||
})
|
||||
.toBe(true);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
const nested = page.getByRole("listbox", { name: "archive" });
|
||||
await expect(nested.getByRole("option", { name: "Previous.ts" })).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
await expect(archive).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(list).toBeHidden();
|
||||
await expect(anchor).toBeFocused();
|
||||
});
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("Paste from History keeps the list and preview usable in a short dialog", async ({ workbench: page }) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
await content.focus();
|
||||
const baseFont = Number.parseFloat(await content.evaluate((el) => getComputedStyle(el).fontSize));
|
||||
await page.evaluate(async () => {
|
||||
const source = await (await fetch("/src/editor/core/extras.ts")).text();
|
||||
const imports = [...source.matchAll(/["'](\/src\/[^"']+)["']/g)].map((match) => match[1]!);
|
||||
const activePath = (path: string) => imports.find((url) => url.split("?")[0] === path) ?? path;
|
||||
const historyPath = activePath("/src/editor/core/clipboardHistory.ts");
|
||||
const actionsPath = activePath("/src/platform/actions.ts");
|
||||
const { recordClipboard } = await import(/* @vite-ignore */ historyPath);
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsPath);
|
||||
recordClipboard("const older = 2;");
|
||||
recordClipboard("const newest = 1;\n// paste marker");
|
||||
Object.defineProperty(navigator, "clipboard", { configurable: true, value: { writeText: async () => {} } });
|
||||
for (let i = 0; i < 5; i++) await executeAction("editor.increaseFontSize");
|
||||
});
|
||||
const fontSize = `${baseFont + 5}px`;
|
||||
await expect(content).toHaveCSS("font-size", fontSize);
|
||||
await page.keyboard.press("Meta+Shift+v");
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Choose Content to Paste" });
|
||||
const divider = dialog.getByRole("separator", { name: "Resize paste preview" });
|
||||
const list = dialog.getByRole("listbox", { name: "Clipboard history" });
|
||||
const preview = dialog.getByLabel("Paste preview", { exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await expect(list.getByText("const newest = 1;", { exact: true })).toHaveCSS("font-size", fontSize);
|
||||
await expect(preview).toHaveCSS("font-size", fontSize);
|
||||
await expect(dialog.locator(".cm-gutters")).toHaveCount(0);
|
||||
|
||||
await page.setViewportSize({ width: 420, height: 440 });
|
||||
const search = dialog.getByRole("textbox", { name: "Filter clipboard history" });
|
||||
const remove = dialog.getByRole("button", { name: "Delete" });
|
||||
await expect(search).toBeInViewport({ ratio: 1 });
|
||||
await expect(remove).toBeInViewport({ ratio: 1 });
|
||||
expect((await remove.boundingBox())!.y).toBeLessThan((await list.boundingBox())!.y);
|
||||
const previous = Number(await divider.getAttribute("aria-valuenow"));
|
||||
await divider.press("ArrowDown");
|
||||
await expect.poll(async () => Number(await divider.getAttribute("aria-valuenow"))).toBeGreaterThan(previous);
|
||||
const resized = await divider.getAttribute("aria-valuenow");
|
||||
await expect(dialog.getByRole("button", { name: "Paste" })).toBeInViewport({ ratio: 1 });
|
||||
await expect(preview).toContainText("// paste marker");
|
||||
|
||||
await search.fill("older");
|
||||
await remove.click();
|
||||
await expect(dialog.getByText("No matches", { exact: true })).toBeVisible();
|
||||
await dialog.getByRole("button", { name: "Clear", exact: true }).click();
|
||||
await expect(search).toHaveValue("");
|
||||
await search.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect(content).toContainText("const newest = 1;");
|
||||
|
||||
await page.keyboard.press("Meta+Shift+v");
|
||||
await expect(divider).toHaveAttribute("aria-valuenow", resized!);
|
||||
await page.keyboard.press("Escape");
|
||||
});
|
||||
@@ -1,4 +1,4 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test.use({ video: "on" });
|
||||
|
||||
@@ -100,46 +100,3 @@ test("uses the single project's type in the keyboard New popup", async ({ workbe
|
||||
page.getByRole("dialog", { name: "New File from Template" }).getByText("Go File", { exact: true }),
|
||||
).toBeVisible();
|
||||
});
|
||||
|
||||
test("names a file from a template and keeps keyboard kind selection visible in a short window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const root = "/dev/acme-api";
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.fs_create_file = () => null;
|
||||
});
|
||||
await page.locator(`[data-project-path="${root}"]`).click();
|
||||
await page.keyboard.press("Meta+n");
|
||||
const menu = page.getByRole("dialog", { name: "New", exact: true });
|
||||
await menu.getByRole("textbox", { name: "Search for file type" }).fill("from template");
|
||||
await menu.getByText("From Template…", { exact: true }).click();
|
||||
const templates = page.getByRole("dialog", { name: "New File from Template" });
|
||||
const kotlin = templates.getByRole("option", { name: "Kotlin Class/File", exact: true });
|
||||
await kotlin.hover();
|
||||
await expect(kotlin).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("Enter");
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "New Kotlin Class/File", exact: true });
|
||||
const name = dialog.getByRole("textbox", { name: "Name", exact: true });
|
||||
const kinds = dialog.getByRole("listbox", { name: "Kind", exact: true });
|
||||
await expect(name).toBeFocused();
|
||||
await page.setViewportSize({ width: 430, height: 380 });
|
||||
const bounds = (await dialog.boundingBox())!;
|
||||
expect(Math.abs(bounds.y + bounds.height / 2 - 190)).toBeLessThan(12);
|
||||
await expect.poll(() => kinds.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeGreaterThan(0);
|
||||
|
||||
await name.press("Enter");
|
||||
await expect(dialog.getByRole("alert")).toHaveText("Enter a name");
|
||||
await name.fill("OrderSummary");
|
||||
await name.press("ArrowUp");
|
||||
const last = kinds.getByRole("option", { name: "JUnit 5 Test", selected: true });
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(name).toBeFocused();
|
||||
for (let i = 0; i < 3; i++) await name.press("ArrowUp");
|
||||
await expect(kinds.getByRole("option", { name: "Data class", selected: true })).toBeVisible();
|
||||
await name.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect.poll(() => ipcCalls(page, "fs_create_file")).toEqual([{ path: `${root}/OrderSummary.kt` }]);
|
||||
await expect(page.getByRole("tab", { name: "OrderSummary.kt" })).toHaveAttribute("aria-selected", "true");
|
||||
});
|
||||
@@ -37,30 +37,6 @@ test("type-ahead jumps to a matching node", async ({ workbench: page }) => {
|
||||
await expect(tree.locator('[role="treeitem"][aria-selected="true"]')).toHaveText("README.md");
|
||||
});
|
||||
|
||||
test("the file deletion form keeps its option and buttons visible in a narrow window", async ({ workbench: page }) => {
|
||||
const file = page.getByRole("treeitem", { name: "README.md", exact: true });
|
||||
await file.click({ button: "right" });
|
||||
await page.getByRole("menuitem", { name: /^Delete…/ }).click();
|
||||
const dialog = page.getByRole("dialog", { name: "Delete", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
await page.setViewportSize({ width: 430, height: 530 });
|
||||
await expect(dialog.locator("[data-dialog-titlebar]")).toContainText("Delete");
|
||||
await expect(dialog).toContainText("Delete 'README.md'?");
|
||||
await expect(dialog).toContainText("Items are moved to the Trash.");
|
||||
const search = dialog.getByRole("checkbox", { name: "Safe delete (with usage search)", exact: true });
|
||||
await expect(search).toBeChecked();
|
||||
await expect(dialog.getByRole("button", { name: "Delete", exact: true })).toBeFocused();
|
||||
await expect(dialog.getByRole("button", { name: "Cancel", exact: true })).toBeInViewport();
|
||||
const option = await search.boundingBox();
|
||||
const footer = await dialog.locator("[data-dialog-footer]").boundingBox();
|
||||
expect(option!.y + option!.height).toBeLessThan(footer!.y);
|
||||
await search.uncheck();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
await page.setViewportSize({ width: 1100, height: 730 });
|
||||
await expect(file).toBeVisible();
|
||||
});
|
||||
|
||||
test("Git ignore submenu offers shared and local destinations for files and folders", async ({ workbench: page }) => {
|
||||
for (const name of ["README.md", "src"]) {
|
||||
await page.getByRole("treeitem", { name, exact: true }).click({ button: "right" });
|
||||
@@ -134,29 +110,3 @@ test("a real mouse drag still shows the drag label until release", async ({ work
|
||||
await page.mouse.up();
|
||||
await expect(dragLabel).toHaveCount(0);
|
||||
});
|
||||
|
||||
test("Copy aligns the file fields and keeps the open-in-editor option in the footer", async ({ workbench: page }) => {
|
||||
await page.getByRole("treeitem", { name: "README.md", exact: true }).click();
|
||||
await page.keyboard.press("F5");
|
||||
const dialog = page.getByRole("dialog", { name: "Copy", exact: true });
|
||||
const name = dialog.getByRole("textbox", { name: "New name" });
|
||||
const target = dialog.getByRole("textbox", { name: "Target directory" });
|
||||
const openCopy = dialog.getByRole("checkbox", { name: "Open copy in editor" });
|
||||
await expect(name).toBeFocused();
|
||||
expect(await name.evaluate((el: HTMLInputElement) => el.value.slice(el.selectionStart!, el.selectionEnd!))).toBe(
|
||||
(await name.inputValue()).replace(/\.md$/, ""),
|
||||
);
|
||||
for (const width of [1100, 430]) {
|
||||
await page.setViewportSize({ width, height: 560 });
|
||||
const [nameBox, targetBox] = await Promise.all([name.boundingBox(), target.boundingBox()]);
|
||||
expect(nameBox!.x).toBeCloseTo(targetBox!.x, 0);
|
||||
expect(targetBox!.x).toBeGreaterThan((await dialog.getByText("To directory:", { exact: true }).boundingBox())!.x);
|
||||
await expect(dialog.locator("[data-dialog-footer]").getByRole("checkbox")).toBeInViewport();
|
||||
}
|
||||
await name.fill("release-notes.md");
|
||||
await target.fill("src");
|
||||
await openCopy.check();
|
||||
await dialog.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect(page.getByRole("tab", { name: "release-notes.md" })).toBeVisible();
|
||||
});
|
||||
@@ -1,56 +0,0 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const parent = "/dev/imports/From-vendor/QuarterlySettlementReconciliationAndReportingProjects";
|
||||
const project = `${parent}/settlement-api`;
|
||||
|
||||
test("the trust prompt keeps the folder scope and restricted preview visible in a narrow window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 420, height: 455 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
const h = window.__ipc.handlers;
|
||||
h.project_trust_status = ({ path }) => ({ root: path, trusted: false, decided: false });
|
||||
h.project_trust_set = () => null;
|
||||
h.open_project = ({ path }) => ({ root: path, name: "settlement-api", trusted: false, isGit: false, settings: {} });
|
||||
h.fs_read_dir = () => [];
|
||||
});
|
||||
const open = () =>
|
||||
page.evaluate(async (path) => {
|
||||
const projectModule = "/src/platform/project.ts";
|
||||
const { openProject } = await import(/* @vite-ignore */ projectModule);
|
||||
void openProject(path).catch(() => undefined);
|
||||
}, project);
|
||||
await open();
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Trust and Open Project?" });
|
||||
const restricted = dialog.getByRole("button", { name: "Preview in Restricted Mode" });
|
||||
const folder = dialog.getByRole("checkbox", { name: /Trust projects in/ });
|
||||
const projectAction = dialog.getByRole("button", { name: "Trust Project", exact: true });
|
||||
const folderAction = dialog.getByRole("button", { name: "Trust Folder", exact: true });
|
||||
await expect(restricted).toBeFocused();
|
||||
await expect(projectAction).toBeVisible();
|
||||
await expect(folder).not.toBeChecked();
|
||||
await expect(dialog.getByTitle(project, { exact: true })).toBeVisible();
|
||||
await expect(dialog.getByTitle(parent, { exact: true })).toBeVisible();
|
||||
await folder.check();
|
||||
await expect(folderAction).toHaveCount(1);
|
||||
await expect(projectAction).toHaveCount(0);
|
||||
for (const selector of ["[data-dialog-body]", "[data-dialog-footer]"]) {
|
||||
expect(await dialog.locator(selector).evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
}
|
||||
await expect(restricted).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
expect(await ipcCalls(page, "project_trust_set")).toEqual([]);
|
||||
expect(await ipcCalls(page, "open_project")).toEqual([]);
|
||||
|
||||
await open();
|
||||
await expect(projectAction).toBeVisible();
|
||||
await expect(folder).not.toBeChecked();
|
||||
await folder.check();
|
||||
await restricted.click();
|
||||
await expect(dialog).toBeHidden();
|
||||
expect(await ipcCalls(page, "project_trust_set")).toEqual([{ path: project, trusted: false, folder: false }]);
|
||||
await expect.poll(() => ipcCalls(page, "open_project")).toEqual([{ path: project }]);
|
||||
});
|
||||
@@ -53,8 +53,7 @@ test("Python syntax supplements retain PyCharm colours without a language server
|
||||
await expect(page.locator(".cm-sem-python-predefined-definition")).toHaveCSS("color", "rgb(187, 153, 34)");
|
||||
await expect(page.locator(".cm-sem-python-predefined-usage")).toHaveCSS("color", "rgb(204, 170, 51)");
|
||||
await expect(page.locator(".cm-sem-keyword").filter({ hasText: /^type$/ })).toHaveCSS("color", "rgb(17, 34, 51)");
|
||||
// The scheme is Darcula-based and doesn't name NOT_USED_ELEMENT_ATTRIBUTES: Darcula's #72737A applies.
|
||||
await expect(page.locator(".cm-sem-unused")).toHaveCSS("color", "rgb(114, 115, 122)");
|
||||
await expect(page.locator(".cm-sem-unused")).toHaveCSS("color", "rgb(111, 115, 122)");
|
||||
expect(errors).toEqual([]);
|
||||
await page.screenshot({ path: info.outputPath("python-highlighting.png") });
|
||||
});
|
||||
@@ -1,88 +0,0 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Quick Evaluate opens an object tree that fits the editor and returns focus on Escape", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 445, height: 500 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
const path = "/dev/acme-api/settlement.py";
|
||||
const h = window.__ipc.handlers;
|
||||
const value = (name: string, text: string, typeName: string, variablesReference = 0) => ({
|
||||
name,
|
||||
value: text,
|
||||
typeName,
|
||||
variablesReference,
|
||||
evaluateName: name,
|
||||
});
|
||||
h.fs_probe = () => ({ size: 48, binary: false, tooLarge: false });
|
||||
h.fs_read_text = () => "summary = {}\nsubtotal = 42\n";
|
||||
h.debug_evaluate_in = ({ expression }) =>
|
||||
expression === "summary" ? value("summary", "{...}", "dict", 101) : value("subtotal", "42", "int");
|
||||
h.debug_variables = ({ reference }) =>
|
||||
reference === 101
|
||||
? [value("audit", "{...}", "dict", 102), value("total", "47.74", "float")]
|
||||
: Array.from({ length: 22 }, (_, i) => value(`entry${i.toString().padStart(2, "0")}`, String(i), "int"));
|
||||
h.debug_scopes = () => [];
|
||||
const servicesModule = "/src/workbench/contributions.ts";
|
||||
const { editorService } = await import(/* @vite-ignore */ servicesModule);
|
||||
await editorService().openFile(path, { focus: true });
|
||||
const debugModule = "/src/features/debugger/state.ts";
|
||||
const { adoptSession, publishContext } = await import(/* @vite-ignore */ debugModule);
|
||||
adoptSession(91, {
|
||||
name: "Checkout",
|
||||
adapter: "debugpy",
|
||||
status: "paused",
|
||||
selectedFrame: 11,
|
||||
frames: [{ id: 11, name: "checkout", path, line: 0, column: 0, presentationHint: null }],
|
||||
});
|
||||
publishContext();
|
||||
});
|
||||
const editor = page.locator(".cm-editor");
|
||||
const content = editor.locator(".cm-content");
|
||||
await expect(content).toBeVisible();
|
||||
await content.evaluate((el) => {
|
||||
const { view } = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dispatch({ changes: { from: 0, to: view.state.doc.length, insert: "summary = {}\nsubtotal = 42\n" } });
|
||||
});
|
||||
const evaluate = (line: number) =>
|
||||
content.evaluate(async (el, lineNo) => {
|
||||
const { view } = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dispatch({ selection: { anchor: view.state.doc.line(lineNo).from + 2 } });
|
||||
const actionModule = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actionModule)).executeAction("debug.quickEvaluate");
|
||||
}, line);
|
||||
|
||||
await evaluate(1);
|
||||
const hint = page.locator(".cm-lsp-hint");
|
||||
await expect(hint).toBeVisible();
|
||||
await expect(hint.getByRole("button", { name: "Expand value" })).toHaveCount(0);
|
||||
const tree = hint.getByRole("tree", { name: "summary" });
|
||||
await expect(tree).toBeFocused();
|
||||
await expect(tree.getByText("audit", { exact: true })).toBeVisible();
|
||||
await page.setViewportSize({ width: 400, height: 360 });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const editorBox = (await editor.boundingBox())!;
|
||||
const hintBox = (await hint.boundingBox())!;
|
||||
return hintBox.x >= editorBox.x - 1 && hintBox.x + hintBox.width <= editorBox.x + editorBox.width + 1;
|
||||
})
|
||||
.toBe(true);
|
||||
|
||||
await tree.getByText("audit", { exact: true }).click();
|
||||
await tree.press("ArrowRight");
|
||||
await expect(tree.getByText("entry00", { exact: true })).toBeVisible();
|
||||
expect(await tree.evaluate((el) => el.scrollHeight > el.clientHeight)).toBe(true);
|
||||
await tree.press("Escape");
|
||||
await expect(hint).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
|
||||
await evaluate(2);
|
||||
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" },
|
||||
]);
|
||||
});
|
||||
@@ -84,8 +84,7 @@ test("Recent Locations keeps all snippet lines visible when the editor font grow
|
||||
await expect(code).toHaveCSS("font-size", "19px");
|
||||
await expect(code).toHaveCSS("line-height", "30px");
|
||||
await expect(code).toHaveCSS("font-family", /"Fira Code".*"Maple Mono NF CN"/);
|
||||
// Three 30px lines; layout may land on a fractional pixel.
|
||||
expect((await code.boundingBox())!.height).toBeCloseTo(90, 0);
|
||||
expect((await code.boundingBox())!.height).toBe(90);
|
||||
|
||||
await page.setViewportSize({ width: 400, height: 500 });
|
||||
const filter = dialog.getByRole("textbox", { name: "Filter recent locations" });
|
||||
|
||||
@@ -1,74 +0,0 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Rollback fits a short window and scopes its options to checked files", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 410, height: 330 });
|
||||
await stubDesktop(page);
|
||||
const root = "/dev/settlement-engine";
|
||||
const added = `${root}/ledger/additional-settlement-schedule.txt`;
|
||||
const deleted = `${root}/ledger/retired-settlement-routing.txt`;
|
||||
const modified = Array.from({ length: 16 }, (_, i) => `${root}/ledger/merchant-settlement-batch-${i + 1}.txt`);
|
||||
|
||||
await page.evaluate(
|
||||
async ({ root, added, deleted, modified }) => {
|
||||
const status = [
|
||||
{ path: added, staged: "added", unstaged: null },
|
||||
{ path: deleted, staged: "deleted", unstaged: null },
|
||||
...modified.map((path) => ({ path, staged: null, unstaged: "modified" })),
|
||||
].map((file) => ({ ...file, relPath: file.path.slice(root.length + 1), renamedFrom: null }));
|
||||
const branch = { head: "main", headCommit: "c1", upstream: null, ahead: 0, behind: 0, operation: null };
|
||||
const h = window.__ipc.handlers;
|
||||
h.vcs_branch_info = () => branch;
|
||||
h.vcs_roots = () => [{ root, ...branch }];
|
||||
h.vcs_status = () => status;
|
||||
h.vcs_unstage = () => null;
|
||||
h.vcs_discard = () => null;
|
||||
|
||||
const storeModule = "/src/features/vcs/store.ts";
|
||||
const { useVcs } = await import(/* @vite-ignore */ storeModule);
|
||||
useVcs.setState({ available: true, root, repo: root, roots: [root], branch, status });
|
||||
const contextModule = "/src/platform/context.ts";
|
||||
const { setContext } = await import(/* @vite-ignore */ contextModule);
|
||||
setContext("vcsAvailable", true);
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
await executeAction("vcs.rollback", [root]);
|
||||
},
|
||||
{ root, added, deleted, modified },
|
||||
);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Rollback Changes", exact: true });
|
||||
const tree = dialog.getByRole("tree", { name: "Files to roll back" });
|
||||
const body = dialog.locator("[data-dialog-body]");
|
||||
await expect(tree).toBeVisible();
|
||||
expect(await body.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1);
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBe(0);
|
||||
expect(await tree.evaluate((el) => el.scrollHeight > el.clientHeight)).toBe(true);
|
||||
await expect(tree).toBeFocused();
|
||||
await expect(tree.getByTitle("ledger/additional-settlement-schedule.txt", { exact: true })).toBeVisible();
|
||||
|
||||
const status = dialog.getByRole("status");
|
||||
const deleteCopies = dialog.getByRole("checkbox", { name: "Delete local copies of added files" });
|
||||
const rollback = dialog.getByRole("button", { name: "Rollback", exact: true });
|
||||
await expect(status).toHaveText("1 added16 modified1 deleted");
|
||||
await expect(deleteCopies).toBeEnabled();
|
||||
await expect(deleteCopies).not.toBeChecked();
|
||||
await deleteCopies.check();
|
||||
await tree.getByRole("checkbox", { name: "Include additional-settlement-schedule.txt" }).uncheck();
|
||||
await expect(deleteCopies).toBeDisabled();
|
||||
await expect(status).toHaveText("16 modified1 deleted");
|
||||
|
||||
const rootCheckbox = tree.getByRole("checkbox", { name: "Include settlement-engine", exact: true });
|
||||
await expect(rootCheckbox).toHaveAttribute("aria-checked", "mixed");
|
||||
await rootCheckbox.click();
|
||||
await rootCheckbox.uncheck();
|
||||
await expect(rollback).toBeDisabled();
|
||||
await expect(status).toHaveText("No files selected");
|
||||
|
||||
await tree.getByRole("checkbox", { name: "Include merchant-settlement-batch-1.txt", exact: true }).check();
|
||||
await expect(status).toHaveText("1 modified");
|
||||
await expect(deleteCopies).toBeDisabled();
|
||||
await rollback.click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect.poll(() => ipcCalls(page, "vcs_discard")).toEqual([{ paths: [modified[0]] }]);
|
||||
expect(await ipcCalls(page, "vcs_unstage")).toEqual([]);
|
||||
});
|
||||
@@ -1,79 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("the environment editor resizes both tables and focuses a new variable", async ({ workbench: page }) => {
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/run/store.ts";
|
||||
const { useRun } = await import(/* @vite-ignore */ path);
|
||||
window.__ipc.handlers.run_system_env = () =>
|
||||
Object.fromEntries(Array.from({ length: 28 }, (_, i) => [`SYSTEM_${i + 1}`, `example-${i + 1}`]));
|
||||
useRun.setState({
|
||||
configs: [
|
||||
{
|
||||
id: "layout:env",
|
||||
kind: "shell",
|
||||
name: "Environment example",
|
||||
command: "npm",
|
||||
args: ["start"],
|
||||
env: Object.fromEntries(Array.from({ length: 18 }, (_, i) => [`APP_${i + 1}`, `value-${i + 1}`])),
|
||||
detected: false,
|
||||
isTest: false,
|
||||
debugAdapter: null,
|
||||
},
|
||||
],
|
||||
selectedId: "layout:env",
|
||||
loaded: true,
|
||||
editorOpen: true,
|
||||
});
|
||||
});
|
||||
const configurations = page.getByRole("dialog", { name: "Run/Debug Configurations", exact: true });
|
||||
const edit = configurations.getByRole("button", { name: "Edit Environment Variables" });
|
||||
await edit.click();
|
||||
const dialog = page.getByRole("dialog", { name: "Environment Variables", exact: true });
|
||||
const user = dialog.getByRole("table", { name: "User environment variables" });
|
||||
const system = dialog.getByRole("table", { name: "System environment variables" });
|
||||
await expect(system.getByRole("row")).toHaveCount(29);
|
||||
|
||||
const userHeight = (await user.boundingBox())!.height;
|
||||
const systemHeight = (await system.boundingBox())!.height;
|
||||
const handle = dialog.getByRole("separator", { name: "Resize" });
|
||||
await expect(handle).toBeVisible();
|
||||
const { x, y } = (await handle.boundingBox())!;
|
||||
await page.mouse.move(x + 5, y + 5);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(x + 5, y + 101, { steps: 5 });
|
||||
await page.mouse.up();
|
||||
await expect.poll(async () => (await user.boundingBox())!.height).toBeGreaterThan(userHeight + 30);
|
||||
await expect.poll(async () => (await system.boundingBox())!.height).toBeGreaterThan(systemHeight + 30);
|
||||
|
||||
await system.evaluate((el) => (el.scrollTop = el.scrollHeight));
|
||||
expect(await system.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
expect(await user.evaluate((el) => el.scrollTop)).toBe(0);
|
||||
const columnHeader = (await system.getByRole("columnheader", { name: "Name" }).boundingBox())!;
|
||||
expect(columnHeader.y).toBeGreaterThanOrEqual((await system.boundingBox())!.y);
|
||||
expect(columnHeader.y).toBeLessThan((await system.boundingBox())!.y + columnHeader.height);
|
||||
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await page.setViewportSize({ width: 430, height: 530 });
|
||||
await edit.click();
|
||||
await dialog.getByRole("button", { name: "Add", exact: true }).click();
|
||||
const name = user.getByRole("textbox", { name: "Variable 19 name", exact: true });
|
||||
await expect(name).toBeFocused();
|
||||
await expect(name).toBeInViewport();
|
||||
expect(await user.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
await name.fill("APP_1");
|
||||
await expect(dialog.getByRole("alert")).toHaveText("Duplicate environment variable: APP_1");
|
||||
const ok = dialog.getByRole("button", { name: "OK", exact: true });
|
||||
await expect(ok).toBeDisabled();
|
||||
await expect(ok).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.getByRole("button", { name: "Cancel", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await name.fill("LOG_LEVEL");
|
||||
await user.getByRole("textbox", { name: "Variable 19 value", exact: true }).fill("debug");
|
||||
await dialog.getByRole("checkbox", { name: "Include system environment variables" }).uncheck();
|
||||
await ok.click();
|
||||
await expect(configurations.getByRole("textbox", { name: "Environment variables", exact: true })).toHaveValue(
|
||||
/LOG_LEVEL=debug/,
|
||||
);
|
||||
await edit.click();
|
||||
await expect(dialog.getByRole("checkbox", { name: "Include system environment variables" })).not.toBeChecked();
|
||||
});
|
||||
@@ -1,63 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("keeps scope navigation and editing usable as Settings narrows", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1180, height: 770 });
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
const longName = "Shared API and generated deployment artifacts for regional settlement services";
|
||||
const longPattern = "file:services/settlement//*.ts && !file:*.test.ts";
|
||||
await page.evaluate(
|
||||
async ({ longName, longPattern }) => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
const { selectPage, stage } = await import(/* @vite-ignore */ path);
|
||||
stage("scopes", "project", "scopes", [
|
||||
{ name: longName, pattern: longPattern },
|
||||
...Array.from({ length: 23 }, (_, i) => ({
|
||||
name: `Settlement area ${i + 1}`,
|
||||
pattern: `file:services/area-${i + 1}//*.ts`,
|
||||
})),
|
||||
]);
|
||||
selectPage("scopes");
|
||||
},
|
||||
{ longName, longPattern },
|
||||
);
|
||||
const scopes = dialog.getByRole("listbox", { name: "Scopes", exact: true });
|
||||
const toolbar = dialog.getByRole("toolbar", { name: "Scopes actions" });
|
||||
const name = dialog.getByRole("textbox", { name: /^Name:?$/ });
|
||||
const pattern = dialog.getByRole("textbox", { name: /^Pattern:?$/ });
|
||||
await expect(name).toHaveValue(longName);
|
||||
await expect(pattern).toHaveValue(longPattern);
|
||||
expect((await name.boundingBox())!.x).toBeGreaterThan(
|
||||
(await scopes.boundingBox())!.x + (await scopes.boundingBox())!.width,
|
||||
);
|
||||
const first = scopes.getByRole("option", { name: longName, exact: true });
|
||||
await expect(first.getByTitle(new RegExp(longName))).toBeVisible();
|
||||
expect(await scopes.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await scopes.focus();
|
||||
await page.keyboard.press("End");
|
||||
const last = scopes.getByRole("option", { name: "Settlement area 23", exact: true });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(pattern).toHaveValue("file:services/area-23//*.ts");
|
||||
expect(await scopes.evaluate((el) => el.scrollTop)).toBeGreaterThan(100);
|
||||
await expect(toolbar).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.setViewportSize({ width: 650, height: 730 });
|
||||
const listBounds = (await scopes.boundingBox())!;
|
||||
expect((await name.boundingBox())!.y).toBeGreaterThan(listBounds.y + listBounds.height);
|
||||
await toolbar.getByRole("button", { name: "Add", exact: true }).click();
|
||||
await expect(name).toBeFocused();
|
||||
await expect(name).toHaveValue("Scope");
|
||||
expect(await name.evaluate((el: HTMLInputElement) => [el.selectionStart, el.selectionEnd])).toEqual([0, 5]);
|
||||
const added = scopes.getByRole("option", { name: "Scope", exact: true });
|
||||
await expect(added).toHaveAttribute("aria-selected", "true");
|
||||
await expect(added).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.type("Settlement exports");
|
||||
await pattern.fill("file:exports//*.csv");
|
||||
await expect(scopes.getByRole("option", { name: "Settlement exports", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
});
|
||||
@@ -1,86 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("the scratch language chooser fits short windows and keeps recents separate from search results", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 470, height: 400 });
|
||||
const long = "Zebra Configuration Language for Regional Settlement and Reconciliation Pipelines";
|
||||
await page.evaluate(async (long) => {
|
||||
const scratch = "/src/features/scratch/scratches.ts";
|
||||
const store = "/src/features/scratch/store.ts";
|
||||
const actions = "/src/platform/actions.ts";
|
||||
const { setScratchBackend } = await import(/* @vite-ignore */ scratch);
|
||||
const { rememberLanguage } = await import(/* @vite-ignore */ store);
|
||||
setScratchBackend({
|
||||
dataDir: async () => "/test-app-data",
|
||||
listNames: async () => [],
|
||||
createDir: async () => {},
|
||||
createFile: async () => {},
|
||||
languages: async () => [
|
||||
...Array.from({ length: 24 }, (_, i) => {
|
||||
const n = String(i + 1).padStart(2, "0");
|
||||
return { id: `config-${n}`, name: `Configuration ${n}`, ext: `cfg${n}` };
|
||||
}),
|
||||
{ id: "json", name: "JSON", ext: "json" },
|
||||
{ id: "python", name: "Python", ext: "py" },
|
||||
{ id: "zebra", name: long, ext: "zebra" },
|
||||
],
|
||||
open: async (path: string) => localStorage.setItem("scratch-layout-opened", path),
|
||||
});
|
||||
rememberLanguage("json");
|
||||
rememberLanguage("python");
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("file.newScratchFile");
|
||||
}, long);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "New Scratch File", exact: true });
|
||||
const input = dialog.getByRole("textbox", { name: "Filter languages" });
|
||||
await expect(input).toBeFocused();
|
||||
const list = dialog.getByRole("listbox", { name: "Languages" });
|
||||
for (let i = 0; i < 3; i++) await input.press("PageDown");
|
||||
const last = list.getByRole("option", { name: long, exact: true });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const popup = (await dialog.boundingBox())!;
|
||||
const item = (await last.boundingBox())!;
|
||||
return item.y + item.height - popup.y - popup.height;
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
await expect(last).toBeInViewport({ ratio: 0.99 });
|
||||
await expect(last.getByTitle(long)).toBeVisible();
|
||||
await expect(input).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await input.fill("python");
|
||||
const python = list.getByRole("option", { name: "Python", exact: true });
|
||||
await expect(python).toHaveAttribute("aria-selected", "true");
|
||||
await expect(list.getByRole("separator")).toHaveCount(0);
|
||||
await input.fill("");
|
||||
const divider = list.getByRole("separator");
|
||||
await expect(divider).toBeVisible();
|
||||
await expect(python).toHaveAttribute("aria-selected", "true");
|
||||
await input.press("ArrowDown");
|
||||
const json = list.getByRole("option", { name: "JSON", exact: true });
|
||||
await expect(json).toHaveAttribute("aria-selected", "true");
|
||||
await input.press("ArrowDown");
|
||||
const first = list.getByRole("option", { name: "Configuration 01", exact: true });
|
||||
await expect(first).toHaveAttribute("aria-selected", "true");
|
||||
expect((await divider.boundingBox())!.y).toBeLessThan((await first.boundingBox())!.y);
|
||||
expect(await input.getAttribute("aria-activedescendant")).toBe(await first.getAttribute("id"));
|
||||
await page.setViewportSize({ width: 640, height: 520 });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await dialog.boundingBox())!;
|
||||
return Math.abs(bounds.x + bounds.width / 2 - 320);
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
await expect(input).toBeFocused();
|
||||
|
||||
await input.fill("zzz");
|
||||
await expect(dialog.getByText("No matching languages")).toBeVisible();
|
||||
await input.fill("json");
|
||||
await input.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect
|
||||
.poll(() => page.evaluate(() => localStorage.getItem("scratch-layout-opened")))
|
||||
.toBe("/test-app-data/scratches/scratch.json");
|
||||
});
|
||||
@@ -159,86 +159,3 @@ test("Find in Files streams matches by file and opens the chosen one at its line
|
||||
}, `Editor for ${ROOT}/build.gradle.kts`);
|
||||
await expect.poll(caretLine).toBe("import com.acme.orders.service.OrderService");
|
||||
});
|
||||
|
||||
test("the Find tool window keeps the selected preview and replacement actions when narrowed", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1500, height: 820 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
({ path, relPath }) => {
|
||||
window.__ipc.handlers.search_validate = () => null;
|
||||
window.__ipc.handlers.search_start = ({ query, onEvent }) => {
|
||||
if ((query as SearchQuery).pattern !== "OrderService") return null;
|
||||
setTimeout(() => {
|
||||
window.__ipc.send(onEvent, {
|
||||
type: "file",
|
||||
file: {
|
||||
path,
|
||||
relPath,
|
||||
matches: [
|
||||
{
|
||||
line: 2,
|
||||
text: "import com.acme.orders.service.OrderService",
|
||||
ranges: [[31, 43]],
|
||||
textOffset: 0,
|
||||
},
|
||||
],
|
||||
},
|
||||
});
|
||||
window.__ipc.send(onEvent, {
|
||||
type: "done",
|
||||
summary: { files: 1, matches: 1, limitHit: false, cancelled: false, elapsedMs: 1 },
|
||||
});
|
||||
}, 20);
|
||||
return null;
|
||||
};
|
||||
},
|
||||
{ path: `${ROOT}/build.gradle.kts`, relPath: "build.gradle.kts" },
|
||||
);
|
||||
await page.keyboard.press("Meta+Shift+r");
|
||||
const popup = page.getByRole("dialog", { name: "Replace in Files" });
|
||||
await popup.getByRole("textbox", { name: "Text to find" }).fill("OrderService");
|
||||
await popup.getByRole("textbox", { name: "Replace with" }).fill("OrdersApi");
|
||||
await expect(popup.getByRole("listbox", { name: "Matches" }).getByRole("option")).toHaveCount(1);
|
||||
await popup.getByRole("button", { name: "Open in Find Window", exact: true }).click();
|
||||
|
||||
const find = page.getByRole("region", { name: "Find", exact: true });
|
||||
await find.getByRole("button", { name: "Options", exact: true }).click();
|
||||
await page.getByRole("menuitem", { name: "Move To", exact: true }).hover();
|
||||
await page.getByRole("menuitem", { name: "Right Top", exact: true }).click();
|
||||
|
||||
const dockDivider = page.getByRole("separator", { name: "Resize right tool window", exact: true });
|
||||
const resizeDock = async (width: number) => {
|
||||
await expect(dockDivider).toBeVisible();
|
||||
const handle = (await dockDivider.boundingBox())!;
|
||||
const dock = (await find.boundingBox())!;
|
||||
const x = handle.x + handle.width / 2;
|
||||
const y = handle.y + handle.height / 2;
|
||||
await page.mouse.move(x, y);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(x + dock.width - width, y, { steps: 5 });
|
||||
await page.mouse.up();
|
||||
};
|
||||
await resizeDock(690);
|
||||
const row = find.getByRole("treeitem", { name: /OrderService.*OrdersApi/ });
|
||||
await row.click();
|
||||
const preview = find.getByRole("region", { name: "Preview", exact: true });
|
||||
await expect(preview.locator(".cm-content")).toContainText("OrderService");
|
||||
const divider = find.getByRole("separator", { name: "Resize find preview" });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "vertical");
|
||||
|
||||
await resizeDock(325);
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await expect(row).toHaveAttribute("aria-selected", "true");
|
||||
await expect(preview.locator(".cm-content")).toContainText("OrderService");
|
||||
await expect(find.getByRole("toolbar", { name: "Find actions" })).toHaveAttribute("aria-orientation", "vertical");
|
||||
for (const label of ["Preview", "Replace Selected", "Replace All"]) {
|
||||
await expect(find.getByRole("button", { name: label, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
await find.getByRole("button", { name: "Replace All", exact: true }).click();
|
||||
const confirmation = page.getByRole("dialog", { name: "Replace All" });
|
||||
await expect(confirmation).toBeVisible();
|
||||
await confirmation.getByRole("button", { name: "Cancel" }).click();
|
||||
await expect(confirmation).toBeHidden();
|
||||
});
|
||||
@@ -1,94 +0,0 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("selection history keeps a full-width diff above a keyboard-resizable revision table", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1140, height: 740 });
|
||||
const filename = "QuarterlyCrossBorderSettlementReconciliationProjection.ts";
|
||||
const path = `/dev/acme-api/modules/${filename}`;
|
||||
const lastMessage = "Introduce the reconciliation projection for pending cross-border merchant settlements";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend))
|
||||
.docBackend()
|
||||
.files.set(path, "export const pending = 0;\nconst projection = uncommitted;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
const editor = page.locator(".cm-content");
|
||||
await expect(editor).toContainText("uncommitted");
|
||||
await editor.evaluate((el) => {
|
||||
const view = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
const line = view.state.doc.line(2);
|
||||
view.dispatch({ selection: { anchor: line.from, head: line.to } });
|
||||
view.focus();
|
||||
});
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, lastMessage }) => {
|
||||
window.__ipc.handlers.cancel_request = () => null;
|
||||
window.__ipc.handlers.vcs_block_history = () => ({
|
||||
headLines: [1, 1],
|
||||
revisions: Array.from({ length: 22 }, (_, i) => ({
|
||||
id: (i + 16).toString(16).padStart(40, "0"),
|
||||
shortId: (i + 16).toString(16).padStart(7, "0"),
|
||||
author: "Alexandra Reconciliation Coordinator",
|
||||
email: "[email protected]",
|
||||
timeMs: 1738329600000 - i * 86400000,
|
||||
summary: i === 21 ? lastMessage : `Update reconciliation estimate ${22 - i}`,
|
||||
path,
|
||||
before: `const projection = estimate${21 - i};\n`,
|
||||
after: `const projection = estimate${22 - i};\n`,
|
||||
beforeLine: 1,
|
||||
afterLine: 1,
|
||||
})),
|
||||
});
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("vcs.showHistoryForSelection");
|
||||
},
|
||||
{ path, lastMessage },
|
||||
);
|
||||
|
||||
const diff = page.locator(".cm-mergeView");
|
||||
await expect(diff).toContainText("uncommitted");
|
||||
const revisions = page.getByRole("grid", { name: "Revisions" });
|
||||
const history = revisions.or(page.getByRole("listbox", { name: "Revisions" }));
|
||||
await expect(history).toBeVisible();
|
||||
const preview = (await diff.boundingBox())!;
|
||||
const list = (await history.boundingBox())!;
|
||||
expect(list.y).toBeGreaterThanOrEqual(preview.y + preview.height - 1);
|
||||
expect(preview.width).toBeGreaterThanOrEqual(list.width - 2);
|
||||
|
||||
await expect(revisions.getByRole("columnheader")).toHaveText(["Revision", "Date", "Author", "Message"]);
|
||||
const divider = page.getByRole("separator", { name: "Revisions", exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
const initial = (await divider.boundingBox())!.y;
|
||||
await divider.press("ArrowUp");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeLessThan(initial);
|
||||
await expect(revisions.getByRole("row", { selected: true })).toContainText("Local Changes");
|
||||
|
||||
await page.setViewportSize({ width: 490, height: 620 });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await expect(page.getByTitle(`${filename}:2-2`, { exact: true })).toBeVisible();
|
||||
const body = revisions.getByRole("rowgroup");
|
||||
await body.press("End");
|
||||
const last = revisions.getByRole("row", { selected: true });
|
||||
await expect(last.getByRole("gridcell", { name: lastMessage, exact: true })).toHaveAttribute("title", lastMessage);
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const listBounds = (await body.boundingBox())!;
|
||||
const rowBounds = (await last.boundingBox())!;
|
||||
return Math.max(listBounds.y - rowBounds.y, rowBounds.y + rowBounds.height - listBounds.y - listBounds.height);
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
const headers = revisions.getByRole("columnheader");
|
||||
const cells = last.getByRole("gridcell");
|
||||
for (let i = 0; i < 4; i++) {
|
||||
expect(
|
||||
Math.abs((await headers.nth(i).boundingBox())!.x - (await cells.nth(i).boundingBox())!.x),
|
||||
).toBeLessThanOrEqual(1);
|
||||
}
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(diff).toContainText("estimate1");
|
||||
});
|
||||
@@ -1,4 +1,4 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("Add Python Interpreter keeps environment labels and fields inside their rows", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
@@ -80,84 +80,6 @@ test("⌘, opens Settings with the page tree; Escape closes", async ({ workbench
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
|
||||
test("Directory Mappings keeps the controls and headers visible while scrolling repositories", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 760, height: 550 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
const parent = "/dev/acme-api/integrations/finance-and-order-reconciliation";
|
||||
window.__ipc.handlers.vcs_detected_roots = () =>
|
||||
Array.from({ length: 32 }, (_, i) =>
|
||||
`${parent}/ledger-adapter-${String(i + 1).padStart(2, "0")}`.replaceAll("/", "\\"),
|
||||
);
|
||||
window.__ipc.handlers["plugin:dialog|open"] = () => `${parent}/billing-audit-adapter`;
|
||||
});
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("textbox", { name: "Search settings" }).fill("Directory Mappings");
|
||||
await settings.getByRole("treeitem", { name: "Directory Mappings", exact: true }).click();
|
||||
const table = settings.getByRole("table", { name: "Directory mappings", exact: true });
|
||||
await expect(table.getByRole("row")).toHaveCount(33);
|
||||
const header = table.getByRole("columnheader", { name: "Directory", exact: true });
|
||||
const vcsHeader = table.getByRole("columnheader", { name: "VCS", exact: true });
|
||||
const toolbar = settings.getByRole("toolbar", { name: "Directory mappings actions" });
|
||||
const directoryBox = (await header.boundingBox())!;
|
||||
expect(directoryBox.width).toBeGreaterThan(2 * (await vcsHeader.boundingBox())!.width);
|
||||
|
||||
const viewport = table.locator("xpath=..");
|
||||
await expect.poll(() => viewport.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeGreaterThan(0);
|
||||
expect(await viewport.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await viewport.evaluate((el) => (el.scrollTop = el.scrollHeight));
|
||||
await expect(toolbar.getByRole("button", { name: "Add", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
expect(Math.abs((await header.boundingBox())!.y - directoryBox.y)).toBeLessThan(1);
|
||||
|
||||
const repo = table.getByRole("row").filter({ hasText: "ledger-adapter-32" });
|
||||
const name = repo.getByText("ledger-adapter-32", { exact: true });
|
||||
await expect(name).toBeInViewport({ ratio: 1 });
|
||||
expect(await name.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
const vcs = repo.getByRole("button", {
|
||||
name: "VCS of integrations/finance-and-order-reconciliation/ledger-adapter-32",
|
||||
exact: true,
|
||||
});
|
||||
await vcs.click();
|
||||
await page.getByRole("option", { name: "<none>", exact: true }).click();
|
||||
await expect(vcs).toHaveText("<none>");
|
||||
|
||||
await toolbar.getByRole("button", { name: "Add", exact: true }).click();
|
||||
const added = table.getByRole("row").filter({ hasText: "billing-audit-adapter" });
|
||||
await expect(added.getByText("billing-audit-adapter", { exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await expect(added).toHaveAttribute("aria-selected", "true");
|
||||
await toolbar.getByRole("button", { name: "Remove", exact: true }).click();
|
||||
await expect(added).toHaveCount(0);
|
||||
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(settings).toBeHidden();
|
||||
});
|
||||
|
||||
test("editor appearance groups related controls and keeps whitespace options editable", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("textbox", { name: "Search settings" }).fill("Show whitespaces");
|
||||
await settings.getByRole("treeitem", { name: "Appearance", exact: true }).click();
|
||||
const section = (name: string) => settings.getByRole("region", { name, exact: true });
|
||||
|
||||
await expect(section("Caret").getByRole("checkbox", { name: "Use block caret" })).toBeVisible();
|
||||
await expect(section("Code Structure").getByRole("checkbox", { name: "Show line numbers" })).toBeVisible();
|
||||
await expect(section("Code Assistance").getByRole("checkbox", { name: "Show intention bulb" })).toBeVisible();
|
||||
const presentation = section("Presentation");
|
||||
await expect(presentation.getByRole("checkbox", { name: "Render documentation comments" })).toBeVisible();
|
||||
await expect(presentation.getByRole("textbox", { name: "Distraction free mode text width:" })).toBeVisible();
|
||||
const whitespace = presentation.getByRole("checkbox", { name: "Show whitespaces" });
|
||||
const leading = presentation.getByRole("checkbox", { name: "Leading", exact: true });
|
||||
if (await whitespace.isChecked()) await whitespace.uncheck();
|
||||
await expect(leading).toBeDisabled();
|
||||
await whitespace.check();
|
||||
await expect(leading).toBeEnabled();
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(settings).toBeHidden();
|
||||
});
|
||||
|
||||
test("Language Servers page installs a tool with progress (in-memory installer)", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings" });
|
||||
|
||||
@@ -2,9 +2,9 @@ import { expect, test } from "./fixtures";
|
||||
|
||||
for (const [id, selector] of [
|
||||
["build.deployment", "[class*='layout'] > [class*='note']"],
|
||||
["editor.inspections", "[class*='split'] section[class*='details']"],
|
||||
["editor.inspections", "[class*='split'] > [class*='details']"],
|
||||
["languages.servers", "[class*='body'] > [class*='language'][aria-label]"],
|
||||
["plugins", "[class*='body'] [class*='details'][aria-label]"],
|
||||
["plugins", "[class*='body'] > [class*='details']"],
|
||||
["agents.list", "section[aria-label='Codex']"],
|
||||
] as const) {
|
||||
test(`${id} keeps its details usable beside the list`, async ({ workbench: page }) => {
|
||||
|
||||
@@ -1,65 +0,0 @@
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("Switcher keeps the open file list and path visible in a narrow workbench", async ({ workbench: page }) => {
|
||||
await openFromTree(page, "README.md");
|
||||
await openFromTree(page, "App.tsx");
|
||||
await page.keyboard.down("Control");
|
||||
await page.keyboard.press("Tab");
|
||||
|
||||
const switcher = page.getByRole("dialog", { name: "Switcher", exact: true });
|
||||
const files = switcher.getByRole("listbox", { name: "Open files" });
|
||||
const tools = switcher.getByRole("listbox", { name: "Tool windows" });
|
||||
const selected = files.getByRole("option", { selected: true });
|
||||
await expect(selected).toHaveText("README.md");
|
||||
expect((await switcher.boundingBox())!.width).toBeLessThan(600);
|
||||
|
||||
await page.setViewportSize({ width: 400, height: 500 });
|
||||
await expect.poll(async () => (await files.boundingBox())!.width).toBeGreaterThan(225);
|
||||
const footer = switcher.locator("footer");
|
||||
await expect(footer).toHaveText(/README\.md$/);
|
||||
await expect(footer).toBeInViewport({ ratio: 1 });
|
||||
await expect(footer).toHaveCSS("font-size", "12px");
|
||||
expect(await tools.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
expect(await files.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
const structure = tools.getByText("Structure", { exact: true });
|
||||
expect(await structure.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await page.keyboard.press("Tab");
|
||||
const activeTool = tools.getByRole("option", { selected: true });
|
||||
await expect(activeTool).toBeInViewport({ ratio: 1 });
|
||||
const firstTool = await activeTool.getAttribute("aria-posinset");
|
||||
await page.keyboard.press("PageDown");
|
||||
await page.keyboard.press("PageDown");
|
||||
await expect(activeTool).not.toHaveAttribute("aria-posinset", firstTool!);
|
||||
await expect(activeTool).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await tools.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
await page.keyboard.press("Shift+Tab");
|
||||
await expect(selected).toHaveText("README.md");
|
||||
await page.keyboard.up("Control");
|
||||
|
||||
await expect(switcher).toBeHidden();
|
||||
await expect(page.getByRole("tab", { name: "README.md", exact: true })).toHaveAttribute("aria-selected", "true");
|
||||
});
|
||||
|
||||
test("Switcher takes up less space when both lists have only a few entries", async ({ workbench: page }) => {
|
||||
await openFromTree(page, "README.md");
|
||||
await openFromTree(page, "App.tsx");
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/workbench/contributions.ts";
|
||||
const { useContributions } = (await import(
|
||||
/* @vite-ignore */ path
|
||||
)) as typeof import("../src/workbench/contributions");
|
||||
useContributions.setState(({ toolWindows }) => ({
|
||||
toolWindows: new Map([...toolWindows].filter(([id]) => id === "project" || id === "terminal")),
|
||||
}));
|
||||
});
|
||||
await page.keyboard.down("Control");
|
||||
await page.keyboard.press("Tab");
|
||||
const switcher = page.getByRole("dialog", { name: "Switcher", exact: true });
|
||||
const tools = switcher.getByRole("listbox", { name: "Tool windows" });
|
||||
await expect(tools.getByRole("option")).toHaveCount(2);
|
||||
await expect.poll(async () => (await switcher.boundingBox())!.height).toBeLessThan(380);
|
||||
await expect(switcher.locator("footer")).toHaveText(/README\.md$/);
|
||||
await page.keyboard.press("Escape");
|
||||
await page.keyboard.up("Control");
|
||||
});
|
||||
Бінарний файл не відображається.
@@ -120,17 +120,6 @@ public final class OpenIdeaJdbc {
|
||||
n++;
|
||||
}
|
||||
}
|
||||
} else if (op.equals("schemaColumns")) {
|
||||
// Every column of the namespace in one call (SQL completion), without primary keys.
|
||||
header(out, "table", "name", "type", "nullable", "default");
|
||||
try (ResultSet rs = m.getColumns(catalog, schema, "%", "%")) {
|
||||
int n = 0;
|
||||
while (rs.next() && n < 100000) {
|
||||
row(out, rs.getString("TABLE_NAME"), rs.getString("COLUMN_NAME"), rs.getString("TYPE_NAME"),
|
||||
rs.getInt("NULLABLE") == 0 ? "0" : "1", rs.getString("COLUMN_DEF"));
|
||||
n++;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
header(out, "name", "type", "nullable", "default", "primary");
|
||||
String table = a.get(1);
|
||||
@@ -244,7 +233,7 @@ public final class OpenIdeaJdbc {
|
||||
switch (op) {
|
||||
case "open" -> open(a, reply);
|
||||
case "schemas" -> schemas(reply);
|
||||
case "tables", "columns", "schemaColumns" -> metadata(op, a, reply);
|
||||
case "tables", "columns" -> metadata(op, a, reply);
|
||||
case "namespace" -> {
|
||||
header(reply, "namespace");
|
||||
String name = null;
|
||||
@@ -254,20 +243,6 @@ public final class OpenIdeaJdbc {
|
||||
} catch (SQLException | AbstractMethodError ignored) {}
|
||||
row(reply, name);
|
||||
}
|
||||
case "valid" -> {
|
||||
// After a failed statement: whether the session survived (a dropped TCP
|
||||
// connection leaves every later statement failing until the IDE reconnects).
|
||||
header(reply, "valid");
|
||||
boolean valid;
|
||||
try {
|
||||
valid = connection != null && !connection.isClosed() && connection.isValid(5);
|
||||
} catch (AbstractMethodError | SQLFeatureNotSupportedException e) {
|
||||
valid = true; // A pre-JDBC 4 driver cannot tell: keep the session.
|
||||
} catch (SQLException e) {
|
||||
valid = false;
|
||||
}
|
||||
row(reply, Boolean.toString(valid));
|
||||
}
|
||||
case "page" -> execute(work, a, reply, true);
|
||||
case "query" -> {
|
||||
if (a.size() == 3 || a.get(3).isEmpty()) {
|
||||
|
||||
@@ -14,7 +14,6 @@ import java.util.logging.Logger;
|
||||
public class SelfTest {
|
||||
public static class Fixture implements Driver {
|
||||
private boolean readonly;
|
||||
private boolean dropped;
|
||||
private int changes;
|
||||
private Path started;
|
||||
|
||||
@@ -30,12 +29,6 @@ public class SelfTest {
|
||||
case "getDatabaseProductName" -> "Fixture";
|
||||
case "getDatabaseProductVersion" -> "1";
|
||||
case "getIdentifierQuoteString" -> "\"";
|
||||
case "getSearchStringEscape" -> "\\";
|
||||
case "getSchemas" -> rows(List.of(Map.of("TABLE_SCHEM", "app")));
|
||||
case "getColumns" -> "app".equals(a[1]) && "%".equals(a[2]) ? rows(List.of(
|
||||
Map.of("TABLE_NAME", "orders", "COLUMN_NAME", "id", "TYPE_NAME", "INT", "NULLABLE", 0),
|
||||
Map.of("TABLE_NAME", "orders", "COLUMN_NAME", "note", "TYPE_NAME", "VARCHAR", "NULLABLE", 1,
|
||||
"COLUMN_DEF", "'none'"))) : rows(List.of());
|
||||
default -> throw new SQLFeatureNotSupportedException();
|
||||
});
|
||||
return proxy(Connection.class, (p, m, a) -> switch (m.getName()) {
|
||||
@@ -43,21 +36,6 @@ public class SelfTest {
|
||||
case "getMetaData" -> meta;
|
||||
case "close" -> null;
|
||||
case "createStatement" -> statement();
|
||||
case "isClosed" -> false;
|
||||
case "isValid" -> !dropped;
|
||||
case "getCatalog" -> null;
|
||||
default -> throw new SQLFeatureNotSupportedException();
|
||||
});
|
||||
}
|
||||
|
||||
/** A forward-only result set over `data`, read by column label. */
|
||||
static ResultSet rows(List<Map<String, Object>> data) {
|
||||
int[] at = {-1};
|
||||
return proxy(ResultSet.class, (p, m, a) -> switch (m.getName()) {
|
||||
case "next" -> ++at[0] < data.size();
|
||||
case "getString" -> (String) data.get(at[0]).get((String) a[0]);
|
||||
case "getInt" -> (Integer) data.get(at[0]).getOrDefault((String) a[0], 0);
|
||||
case "close" -> null;
|
||||
default -> throw new SQLFeatureNotSupportedException();
|
||||
});
|
||||
}
|
||||
@@ -75,7 +53,6 @@ public class SelfTest {
|
||||
throw new SQLException("statement cancelled");
|
||||
}
|
||||
if (sql.equals("write") && readonly) throw new SQLException("read-only");
|
||||
if (sql.equals("drop")) { dropped = true; throw new SQLException("connection reset"); }
|
||||
changes++;
|
||||
yield false;
|
||||
}
|
||||
@@ -145,15 +122,6 @@ public class SelfTest {
|
||||
send(out, 5, "query", "after cancel", "0", "2");
|
||||
var result = reply(in);
|
||||
assert result[0] == 1 && result[result.length - 1] == 2;
|
||||
send(out, 6, "valid");
|
||||
assert new String(reply(in), StandardCharsets.UTF_8).contains("true");
|
||||
send(out, 7, "query", "drop", "0", "2");
|
||||
assert reply(in)[0] == 0;
|
||||
send(out, 8, "valid");
|
||||
assert new String(reply(in), StandardCharsets.UTF_8).contains("false");
|
||||
send(out, 9, "schemaColumns", "app");
|
||||
var columns = new String(reply(in), StandardCharsets.UTF_8);
|
||||
assert columns.contains("orders") && columns.contains("note") && columns.contains("'none'") : columns;
|
||||
} finally {
|
||||
child.destroyForcibly().waitFor();
|
||||
}
|
||||
|
||||
+3
-3
@@ -73,9 +73,9 @@
|
||||
"@tauri-apps/api": "^2",
|
||||
"@tauri-apps/plugin-dialog": "^2.8.3",
|
||||
"@tauri-apps/plugin-opener": "^2",
|
||||
"@xterm/addon-fit": "0.12.0-beta.334",
|
||||
"@xterm/addon-search": "0.17.0-beta.332",
|
||||
"@xterm/xterm": "6.1.0-beta.338",
|
||||
"@xterm/addon-fit": "^0.11.0",
|
||||
"@xterm/addon-search": "^0.16.0",
|
||||
"@xterm/xterm": "^6.0.0",
|
||||
"anser": "^2.3.5",
|
||||
"clsx": "^2.1.1",
|
||||
"dompurify": "^3.4.17",
|
||||
|
||||
Створено
+15
-23
@@ -102,14 +102,14 @@ importers:
|
||||
specifier: ^2
|
||||
version: 2.7.2
|
||||
'@xterm/addon-fit':
|
||||
specifier: 0.12.0-beta.334
|
||||
version: 0.12.0-beta.334(@xterm/[email protected])
|
||||
specifier: ^0.11.0
|
||||
version: 0.11.0
|
||||
'@xterm/addon-search':
|
||||
specifier: 0.17.0-beta.332
|
||||
version: 0.17.0-beta.332(@xterm/[email protected])
|
||||
specifier: ^0.16.0
|
||||
version: 0.16.0
|
||||
'@xterm/xterm':
|
||||
specifier: 6.1.0-beta.338
|
||||
version: 6.1.0-beta.338
|
||||
specifier: ^6.0.0
|
||||
version: 6.0.0
|
||||
anser:
|
||||
specifier: ^2.3.5
|
||||
version: 2.3.5
|
||||
@@ -1452,18 +1452,14 @@ packages:
|
||||
'@vitest/[email protected]':
|
||||
resolution: {integrity: sha512-lwJRExuH417257Q5wv9QYugN9IMJkoxcrKrYxGPQkBzl7wlNpTUxD/5yNX4ESKVUIShKPgkGchYPFMWOOk0wzw==}
|
||||
|
||||
'@xterm/[email protected]2.0-beta.334':
|
||||
resolution: {integrity: sha512-fIFQHJ15PER9KhAG24IhA5vF4ysHEKrJgImt/ZqRcahvNUGF1T3WnpJ6bLvlvnsft7bVT0ofBWySx6nxFNAXkA==}
|
||||
peerDependencies:
|
||||
'@xterm/xterm': ^6.1.0-beta.338
|
||||
'@xterm/[email protected]1.0':
|
||||
resolution: {integrity: sha512-jYcgT6xtVYhnhgxh3QgYDnnNMYTcf8ElbxxFzX0IZo+vabQqSPAjC3c1wJrKB5E19VwQei89QCiZZP86DCPF7g==}
|
||||
|
||||
'@xterm/[email protected]7.0-beta.332':
|
||||
resolution: {integrity: sha512-XiyGiCWIRdguk45PiXT9ejuuGcCh0Z46ADBXNK4JNL8ElXIwyJ3uiljjxjFOiZ4QFeSrvhUtaQYgmvtOwWEO1A==}
|
||||
peerDependencies:
|
||||
'@xterm/xterm': ^6.1.0-beta.338
|
||||
'@xterm/[email protected]6.0':
|
||||
resolution: {integrity: sha512-9OeuBFu0/uZJPu+9AHKY6g/w0Czyb/Ut0A5t79I4ULoU4IfU5BEpPFVGQxP4zTTMdfZEYkVIRYbHBX1xWwjeSA==}
|
||||
|
||||
'@xterm/xterm@6.1.0-beta.338':
|
||||
resolution: {integrity: sha512-VBygvapFKV5gsqvVFsk6gYpArn4AXnUtZvt3tfN2LXI284i0mivC6Kus84GMJo0GJPLRFziWcSPVz95nViPuWw==}
|
||||
'@xterm/xterm@6.0.0':
|
||||
resolution: {integrity: sha512-TQwDdQGtwwDt+2cgKDLn0IRaSxYu1tSUjgKarSDkUM0ZNiSRXFpjxEsvc/Zgc5kq5omJ+V0a8/kIM2WD3sMOYg==}
|
||||
|
||||
[email protected]:
|
||||
resolution: {integrity: sha512-vcZjxvvVoxTeR5XBNJB38oTu/7eDCZlwdz32N1eNgpyPF7j/Z7Idf+CUwQOkKKpJ7RJyjxgLHCM7vdIK0iCNMQ==}
|
||||
@@ -3455,15 +3451,11 @@ snapshots:
|
||||
|
||||
'@vitest/[email protected]': {}
|
||||
|
||||
'@xterm/[email protected]2.0-beta.334(@xterm/[email protected])':
|
||||
dependencies:
|
||||
'@xterm/xterm': 6.1.0-beta.338
|
||||
'@xterm/[email protected]1.0': {}
|
||||
|
||||
'@xterm/[email protected]7.0-beta.332(@xterm/[email protected])':
|
||||
dependencies:
|
||||
'@xterm/xterm': 6.1.0-beta.338
|
||||
'@xterm/[email protected]6.0': {}
|
||||
|
||||
'@xterm/xterm@6.1.0-beta.338': {}
|
||||
'@xterm/xterm@6.0.0': {}
|
||||
|
||||
[email protected]: {}
|
||||
|
||||
|
||||
@@ -187,18 +187,6 @@ describe("IntelliJ theme import", () => {
|
||||
});
|
||||
});
|
||||
|
||||
it("takes what a Darcula-based scheme leaves out from Darcula", () => {
|
||||
const s = convertIcls(`<scheme name="Mine" version="142" parent_scheme="Darcula"><attributes>
|
||||
<option name="DEFAULT_KEYWORD"><value><option name="FOREGROUND" value="ff8800"/></value></option>
|
||||
<option name="DEFAULT_STRING"><value/></option>
|
||||
</attributes></scheme>`);
|
||||
expect(s.tokens["--bg-editor"]).toBe("#2b2b2b");
|
||||
expect(s.tokens["--syn-keyword"]).toBe("#ff8800");
|
||||
// An empty entry of its own replaces Darcula's colour.
|
||||
expect(s.tokens["--syn-string"]).toBeUndefined();
|
||||
expect(convertIcls(`<scheme name="I" parent_scheme="Islands Dark"></scheme>`).tokens).toEqual({});
|
||||
});
|
||||
|
||||
it("only targets tokens that exist in tokens.css", () => {
|
||||
const declared = new Set([...css.matchAll(/(--[a-z0-9-]+)\s*:/g)].map((m) => m[1]!));
|
||||
// Read with a fallback by the editor (no tokens.css default), still themeable.
|
||||
|
||||
@@ -1,8 +1,4 @@
|
||||
use ide_core::{EventSink, IdeEvent, SharedSink};
|
||||
use parking_lot::Mutex;
|
||||
use std::collections::{HashMap, VecDeque};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use ide_core::{EventSink, IdeEvent};
|
||||
use tauri::{AppHandle, Emitter, Manager, UserAttentionType};
|
||||
|
||||
/// Name of the single backend → UI event. Payload: [`IdeEvent`].
|
||||
@@ -42,103 +38,6 @@ pub struct TauriSink {
|
||||
pub window: Option<String>,
|
||||
}
|
||||
|
||||
const COALESCE_WINDOW: Duration = Duration::from_millis(16);
|
||||
const MAX_PENDING_DIAGNOSTICS: usize = 4096;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct DiagnosticKey {
|
||||
path: ide_core::IpcPath,
|
||||
source: String,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct PendingDiagnostics {
|
||||
order: VecDeque<DiagnosticKey>,
|
||||
events: HashMap<DiagnosticKey, IdeEvent>,
|
||||
scheduled: bool,
|
||||
}
|
||||
|
||||
fn diagnostic_key(event: &IdeEvent) -> Option<DiagnosticKey> {
|
||||
let IdeEvent::Diagnostics { path, source, .. } = event else {
|
||||
return None;
|
||||
};
|
||||
Some(DiagnosticKey { path: path.clone(), source: source.clone() })
|
||||
}
|
||||
|
||||
fn take_pending(state: &mut PendingDiagnostics) -> Vec<IdeEvent> {
|
||||
let mut events = Vec::with_capacity(state.events.len());
|
||||
for key in state.order.drain(..) {
|
||||
if let Some(event) = state.events.remove(&key) {
|
||||
events.push(event);
|
||||
}
|
||||
}
|
||||
events
|
||||
}
|
||||
|
||||
/// Collapses repeated full-replacement diagnostics for one `(path, source)` into the
|
||||
/// latest event in a frame-sized window. Any other event flushes the pending
|
||||
/// diagnostics first so lifecycle and ordered events cannot overtake them.
|
||||
pub fn coalescing_sink(sink: SharedSink, runtime: tokio::runtime::Handle) -> SharedSink {
|
||||
let pending = Arc::new(Mutex::new(PendingDiagnostics::default()));
|
||||
let dispatch = Arc::new(Mutex::new(()));
|
||||
Arc::new(move |event| {
|
||||
let Some(key) = diagnostic_key(&event) else {
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = take_pending(&mut pending.lock());
|
||||
for pending_event in events {
|
||||
sink.emit(pending_event);
|
||||
}
|
||||
sink.emit(event);
|
||||
return;
|
||||
};
|
||||
|
||||
loop {
|
||||
let schedule = {
|
||||
let mut state = pending.lock();
|
||||
if !state.events.contains_key(&key) && state.events.len() >= MAX_PENDING_DIAGNOSTICS {
|
||||
None
|
||||
} else {
|
||||
if !state.events.contains_key(&key) {
|
||||
state.order.push_back(key.clone());
|
||||
}
|
||||
state.events.insert(key.clone(), event.clone());
|
||||
if state.scheduled {
|
||||
return;
|
||||
}
|
||||
state.scheduled = true;
|
||||
Some(())
|
||||
}
|
||||
};
|
||||
|
||||
if schedule.is_none() {
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = take_pending(&mut pending.lock());
|
||||
for pending_event in events {
|
||||
sink.emit(pending_event);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
let pending = pending.clone();
|
||||
let dispatch = dispatch.clone();
|
||||
let sink = sink.clone();
|
||||
runtime.spawn(async move {
|
||||
tokio::time::sleep(COALESCE_WINDOW).await;
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = {
|
||||
let mut state = pending.lock();
|
||||
state.scheduled = false;
|
||||
take_pending(&mut state)
|
||||
};
|
||||
for event in events {
|
||||
sink.emit(event);
|
||||
}
|
||||
});
|
||||
return;
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// A debug session stopped on a breakpoint: bounce/flash the taskbar icon
|
||||
/// (IDEA) unless the user is already looking at an OpenIDEA window. The focus
|
||||
/// check and the request both touch the windowing system, so they run on the
|
||||
@@ -195,205 +94,3 @@ impl EventSink for TauriSink {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::{Diagnostic, IpcPath, Pos, Range, Severity, TaskId};
|
||||
use parking_lot::Mutex;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::time::Duration;
|
||||
use std::time::Instant;
|
||||
|
||||
fn setup() -> (ide_core::SharedSink, Arc<Mutex<Vec<IdeEvent>>>) {
|
||||
let events = Arc::new(Mutex::new(Vec::new()));
|
||||
let saved = events.clone();
|
||||
(coalescing_sink(Arc::new(move |event| saved.lock().push(event)), tokio::runtime::Handle::current()), events)
|
||||
}
|
||||
|
||||
fn diagnostics(path: &str, source: &str, message: &str) -> IdeEvent {
|
||||
IdeEvent::Diagnostics {
|
||||
path: IpcPath::from(path),
|
||||
source: source.into(),
|
||||
items: vec![Diagnostic {
|
||||
range: Range::point(Pos::new(0, 0)),
|
||||
severity: Severity::Error,
|
||||
message: message.into(),
|
||||
source: None,
|
||||
code: None,
|
||||
unnecessary: false,
|
||||
deprecated: false,
|
||||
server: None,
|
||||
}],
|
||||
}
|
||||
}
|
||||
|
||||
fn task(message: &str, done: bool) -> IdeEvent {
|
||||
IdeEvent::Task {
|
||||
id: TaskId(1),
|
||||
title: "Indexing".into(),
|
||||
message: Some(message.into()),
|
||||
fraction: Some(if done { 1.0 } else { 0.5 }),
|
||||
done,
|
||||
cancellable: !done,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn coalesces_diagnostics_by_path_and_source() {
|
||||
let (sink, events) = setup();
|
||||
for index in 0..100 {
|
||||
sink.emit(diagnostics("/p/a.rs", "rust-analyzer", &format!("old {index}")));
|
||||
}
|
||||
sink.emit(diagnostics("/p/a.rs", "eslint", "lint"));
|
||||
sink.emit(diagnostics("/p/b.rs", "rust-analyzer", "other"));
|
||||
|
||||
assert!(events.lock().is_empty());
|
||||
tokio::task::yield_now().await;
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
tokio::task::yield_now().await;
|
||||
|
||||
{
|
||||
let saved_events = events.lock();
|
||||
assert_eq!(saved_events.len(), 3);
|
||||
assert!(matches!(
|
||||
&saved_events[0],
|
||||
IdeEvent::Diagnostics { path, source, items }
|
||||
if path == &IpcPath::from("/p/a.rs")
|
||||
&& source == "rust-analyzer"
|
||||
&& items[0].message == "old 99"
|
||||
));
|
||||
assert!(matches!(
|
||||
&saved_events[1],
|
||||
IdeEvent::Diagnostics { path, source, .. }
|
||||
if path == &IpcPath::from("/p/a.rs") && source == "eslint"
|
||||
));
|
||||
assert!(matches!(
|
||||
&saved_events[2],
|
||||
IdeEvent::Diagnostics { path, source, .. }
|
||||
if path == &IpcPath::from("/p/b.rs") && source == "rust-analyzer"
|
||||
));
|
||||
}
|
||||
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
assert_eq!(events.lock().len(), 3);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn immediate_events_flush_pending_events_first() {
|
||||
let (sink, events) = setup();
|
||||
sink.emit(diagnostics("/p/a.rs", "rust-analyzer", "before"));
|
||||
sink.emit(diagnostics("/p/b.rs", "rust-analyzer", "other"));
|
||||
sink.emit(IdeEvent::SettingsChanged { key: "editor.fontSize".into() });
|
||||
|
||||
let events = events.lock();
|
||||
assert_eq!(events.len(), 3);
|
||||
assert!(matches!(&events[0], IdeEvent::Diagnostics { .. }));
|
||||
assert!(matches!(&events[1], IdeEvent::Diagnostics { .. }));
|
||||
assert!(matches!(&events[2], IdeEvent::SettingsChanged { .. }));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn lifecycle_events_remain_immediate() {
|
||||
let (sink, events) = setup();
|
||||
sink.emit(task("complete", true));
|
||||
let events = events.lock();
|
||||
assert_eq!(events.len(), 1);
|
||||
assert!(matches!(
|
||||
&events[0],
|
||||
IdeEvent::Task { message, done, .. }
|
||||
if message.as_deref() == Some("complete") && *done
|
||||
));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn diagnostic_buffer_cap_flushes_without_dropping() {
|
||||
let (sink, events) = setup();
|
||||
for index in 0..=MAX_PENDING_DIAGNOSTICS {
|
||||
sink.emit(diagnostics(&format!("/p/{index}.rs"), "rust-analyzer", "diagnostic"));
|
||||
}
|
||||
assert_eq!(events.lock().len(), MAX_PENDING_DIAGNOSTICS);
|
||||
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
assert_eq!(events.lock().len(), MAX_PENDING_DIAGNOSTICS + 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "run for before/after diagnostics transport measurements"]
|
||||
async fn diagnostics_coalescing_benchmark() {
|
||||
const FILES: usize = 2_000;
|
||||
const ROUNDS: usize = 10;
|
||||
let burst: Vec<IdeEvent> = (0..ROUNDS)
|
||||
.flat_map(|round| {
|
||||
(0..FILES).map(move |file| {
|
||||
diagnostics(&format!("/workspace/src/File{file}.rs"), "rust-analyzer", &format!("round-{round}"))
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
let raw_events = Arc::new(AtomicUsize::new(0));
|
||||
let raw_count = raw_events.clone();
|
||||
let raw: SharedSink = Arc::new(move |event| {
|
||||
let encoded = serde_json::to_vec(&event).unwrap();
|
||||
raw_count.fetch_add(1, Ordering::Relaxed);
|
||||
std::hint::black_box(encoded.len());
|
||||
});
|
||||
let raw_started = Instant::now();
|
||||
for event in &burst {
|
||||
raw.emit(event.clone());
|
||||
}
|
||||
let raw_elapsed = raw_started.elapsed();
|
||||
assert_eq!(raw_events.load(Ordering::Relaxed), FILES * ROUNDS);
|
||||
|
||||
let coalesced_events = Arc::new(AtomicUsize::new(0));
|
||||
let delivered_state = Arc::new(Mutex::new(HashMap::<IpcPath, String>::new()));
|
||||
let coalesced_count = coalesced_events.clone();
|
||||
let delivered = delivered_state.clone();
|
||||
let target: SharedSink = Arc::new(move |event| {
|
||||
let encoded = serde_json::to_vec(&event).unwrap();
|
||||
coalesced_count.fetch_add(1, Ordering::Relaxed);
|
||||
if let IdeEvent::Diagnostics { path, items, .. } = event {
|
||||
delivered.lock().insert(path, items[0].message.clone());
|
||||
}
|
||||
std::hint::black_box(encoded.len());
|
||||
});
|
||||
let coalesced = coalescing_sink(target, tokio::runtime::Handle::current());
|
||||
let coalesced_started = Instant::now();
|
||||
for event in &burst {
|
||||
coalesced.emit(event.clone());
|
||||
}
|
||||
|
||||
let expected_last_round = format!("round-{}", ROUNDS - 1);
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
loop {
|
||||
let complete = {
|
||||
let delivered_state = delivered_state.lock();
|
||||
delivered_state.len() == FILES
|
||||
&& delivered_state.values().all(|message| message == &expected_last_round)
|
||||
};
|
||||
if complete {
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "diagnostics did not settle before benchmark timeout");
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
}
|
||||
let coalesced_elapsed = coalesced_started.elapsed();
|
||||
|
||||
let coalesced_count = coalesced_events.load(Ordering::Relaxed);
|
||||
assert!(coalesced_count >= FILES);
|
||||
assert!(coalesced_count < FILES * ROUNDS);
|
||||
let delivered_state = delivered_state.lock();
|
||||
assert_eq!(delivered_state.len(), FILES);
|
||||
assert!(delivered_state.values().all(|message| message == &expected_last_round));
|
||||
println!(
|
||||
"diagnostics transport burst: raw_events={} raw_ms={:.2} coalesced_events={} \
|
||||
coalesced_total_ms={:.2} reduction_pct={:.1}",
|
||||
FILES * ROUNDS,
|
||||
raw_elapsed.as_secs_f64() * 1_000.0,
|
||||
coalesced_count,
|
||||
coalesced_elapsed.as_secs_f64() * 1_000.0,
|
||||
(1.0 - coalesced_count as f64 / (FILES * ROUNDS) as f64) * 100.0,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -288,12 +288,6 @@ pub fn run() {
|
||||
window_groups::frame_changed(window.app_handle(), window.label());
|
||||
}
|
||||
tauri::WindowEvent::Destroyed => {
|
||||
// Also release a view that failed during startup, before the parent could watch it.
|
||||
if let Some(state) = window.try_state::<AppState>()
|
||||
&& let Ok(project) = state.host.project(window.label())
|
||||
{
|
||||
project.agents.unsubscribe(window.label());
|
||||
}
|
||||
window_zoom::forget(window.label());
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
|
||||
Loaded 100 of 359 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача