дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-22 17:40:45 +02:00
Порівняти коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
93cccb9bb5 | ||
|
|
40494f2920 | ||
|
|
c016007a2d | ||
|
|
69ce1ab13d | ||
|
|
fcc8583f36 | ||
|
|
b368f21eb6 | ||
|
|
929866bbc5 | ||
|
|
3c781296d6 |
No files matched your search
@@ -309,9 +309,13 @@ pub async fn lsp_signature_help(host: &Host, window: &str, doc: DocId, pos: Pos)
|
||||
|
||||
pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: GotoKind) -> IdeResult<Vec<Location>> {
|
||||
let target = position_document(host, window, doc, pos).await?;
|
||||
// ⌘B on a declaration shows its usages, also when a plugin's index links the name elsewhere
|
||||
// (a MyBatis mapper method to its XML statement): the server's answer comes along for the
|
||||
// editor to tell.
|
||||
if target == doc
|
||||
&& kind == GotoKind::Definition
|
||||
&& let Some(plugins) = crate::plugins::editor_plugin_host()
|
||||
&& !on_declaration_name(host, window, doc, pos).await
|
||||
{
|
||||
let project = host.project(window)?;
|
||||
// A notebook cell is a language-server document only: no plugin navigates in it.
|
||||
@@ -352,6 +356,30 @@ pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: Got
|
||||
definition_targets(result, found, in_string)
|
||||
}
|
||||
|
||||
/// Whether the syntax tree puts the identifier at `pos` as a declaration's name (`int f()`'s `f`).
|
||||
async fn on_declaration_name(host: &Host, window: &str, doc: DocId, pos: Pos) -> bool {
|
||||
let Ok(project) = host.project(window) else { return false };
|
||||
blocking(move || {
|
||||
let snap = project.documents.text_snapshot(doc)?;
|
||||
if snap.large {
|
||||
return Ok(false);
|
||||
}
|
||||
let s = ide_syntax::Snapshot::doc(doc, snap.version, &snap.language, &snap.text);
|
||||
let cancel = ide_core::CancellationToken::new();
|
||||
let Ok(Some(at)) = project.structure.node_at(&s, Range::new(pos, pos), &cancel) else { return Ok(false) };
|
||||
Ok(is_declaration_name(&at))
|
||||
})
|
||||
.await
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
fn is_declaration_name(at: &ide_syntax::NodeAt) -> bool {
|
||||
at.node.field.as_deref() == Some("name")
|
||||
&& at.ancestors.first().is_some_and(|parent| {
|
||||
["declaration", "definition", "declarator"].iter().any(|kind| parent.kind.ends_with(kind))
|
||||
})
|
||||
}
|
||||
|
||||
async fn in_string_literal(host: &Host, window: &str, doc: DocId, pos: Pos) -> bool {
|
||||
let Ok(project) = host.project(window) else { return false };
|
||||
blocking(move || {
|
||||
@@ -2136,6 +2164,24 @@ mod tests {
|
||||
assert_eq!(paths(definition_targets(Ok(vec![helper, guess]), Vec::new(), false)), ["/p/app/helpers.php"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn declaration_names_are_told_apart_from_uses() {
|
||||
let syntax = std::sync::Arc::new(ide_language::Syntax::new());
|
||||
let structure = ide_syntax::StructureService::new(std::sync::Arc::new(ide_language::SyntaxCache::new(syntax)));
|
||||
let java = ide_core::LanguageId::new("java");
|
||||
let text = "interface ShareMapper {\n int batchCancel(List<Long> ids);\n}\nclass S { int f(ShareMapper m) { return m.batchCancel(null); } }\n";
|
||||
let snap = ide_syntax::Snapshot::text(&java, text);
|
||||
let cancel = ide_core::CancellationToken::new();
|
||||
let at = |line, col| {
|
||||
let pos = Pos::new(line, col);
|
||||
is_declaration_name(&structure.node_at(&snap, Range::new(pos, pos), &cancel).unwrap().unwrap())
|
||||
};
|
||||
assert!(at(1, 10), "the mapper method's name");
|
||||
assert!(at(0, 12), "the interface's name");
|
||||
assert!(!at(3, 45), "a call of the method");
|
||||
assert!(!at(1, 4), "its return type");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn positions_inside_string_literals_are_told_apart() {
|
||||
let syntax = std::sync::Arc::new(ide_language::Syntax::new());
|
||||
|
||||
@@ -223,6 +223,10 @@ pub trait Handler: Send + Sync + 'static {
|
||||
|
||||
/// Called once the response to a `method` request is queued: what it sends follows the response.
|
||||
fn after_response(&self, _method: &str) {}
|
||||
|
||||
/// Adjusts every message from the peer (responses included) before it is dispatched, e.g.
|
||||
/// to repair values the peer spells more loosely than the types that read them accept.
|
||||
fn normalize_incoming(&self, _message: &mut Value) {}
|
||||
}
|
||||
|
||||
/// A [`Handler`] that ignores notifications and rejects requests.
|
||||
@@ -585,9 +589,10 @@ impl Peer {
|
||||
.expect("spawn jsonrpc notification thread");
|
||||
}
|
||||
|
||||
// Reader: parses and dispatches; never runs handler code itself.
|
||||
// Reader: parses and dispatches; runs no handler code beyond `normalize_incoming`.
|
||||
{
|
||||
let inner = inner.clone();
|
||||
let handler = handler.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut reader = BufReader::new(reader);
|
||||
let seen_message = AtomicBool::new(false);
|
||||
@@ -610,7 +615,7 @@ impl Peer {
|
||||
match msg {
|
||||
Ok(Some(body)) => {
|
||||
seen_message.store(true, Ordering::Relaxed);
|
||||
dispatch(&inner, ¬if_tx, &body);
|
||||
dispatch(&inner, &*handler, ¬if_tx, &body);
|
||||
}
|
||||
Ok(None) => break,
|
||||
Err(e) => {
|
||||
@@ -783,15 +788,16 @@ async fn handle_request(inner: Arc<Inner>, handler: Arc<dyn Handler>, id: Value,
|
||||
}
|
||||
}
|
||||
|
||||
fn dispatch(inner: &Arc<Inner>, notif_tx: &std::sync::mpsc::Sender<Incoming>, body: &[u8]) {
|
||||
fn dispatch(inner: &Arc<Inner>, handler: &dyn Handler, notif_tx: &std::sync::mpsc::Sender<Incoming>, body: &[u8]) {
|
||||
tracing::trace!(target: "ide_jsonrpc::wire", "<-- {}", String::from_utf8_lossy(body));
|
||||
let msg: Value = match serde_json::from_slice(body) {
|
||||
let mut msg: Value = match serde_json::from_slice(body) {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
tracing::warn!("jsonrpc: unparsable message: {e}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
handler.normalize_incoming(&mut msg);
|
||||
let Value::Object(mut obj) = msg else {
|
||||
tracing::warn!("jsonrpc: ignoring non-object message");
|
||||
return;
|
||||
|
||||
@@ -541,3 +541,29 @@ async fn output_before_the_handshake_is_reported_not_dropped() {
|
||||
assert!(lines.iter().any(|l| l == "python: not found"), "{lines:?}");
|
||||
assert!(lines.iter().any(|l| l.ends_with(". . .") && l.len() > 6), "{lines:?}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn incoming_messages_are_normalized_before_dispatch() {
|
||||
struct Server;
|
||||
impl Handler for Server {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
fn on_request(&self, _: &str, params: Value) -> Result<Value, (i64, String)> {
|
||||
Ok(params)
|
||||
}
|
||||
}
|
||||
struct Client;
|
||||
impl Handler for Client {
|
||||
fn on_notification(&self, _: &str, _: Value) {}
|
||||
fn on_request(&self, _: &str, _: Value) -> Result<Value, (i64, String)> {
|
||||
Err((codes::METHOD_NOT_FOUND, "no".into()))
|
||||
}
|
||||
fn normalize_incoming(&self, message: &mut Value) {
|
||||
if let Some(result) = message.get_mut("result") {
|
||||
*result = json!("normalized");
|
||||
}
|
||||
}
|
||||
}
|
||||
let (client, _server) = pair(Arc::new(Client), Arc::new(Server));
|
||||
let v: Value = client.request("echo", "raw", None).await.unwrap();
|
||||
assert_eq!(v, json!("normalized"));
|
||||
}
|
||||
@@ -391,6 +391,10 @@ fn tsserver_ran_out_of_memory(text: &str) -> bool {
|
||||
}
|
||||
|
||||
impl Handler for ClientHandler {
|
||||
fn normalize_incoming(&self, message: &mut Value) {
|
||||
crate::uri::encode_loose_file_uris(message);
|
||||
}
|
||||
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
let Some(mgr) = self.mgr.upgrade() else { return };
|
||||
match method {
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
//! `file://` URI ⇄ path conversion (RFC 8089, VS Code-compatible encoding).
|
||||
|
||||
use percent_encoding::{AsciiSet, CONTROLS, percent_decode_str, utf8_percent_encode};
|
||||
use serde_json::Value;
|
||||
use std::borrow::Cow;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::str::FromStr;
|
||||
|
||||
@@ -22,6 +24,53 @@ const PATH: &AsciiSet = &CONTROLS
|
||||
.add(b'|')
|
||||
.add(b'}');
|
||||
|
||||
/// What RFC 3986 doesn't allow in a URI and a server may still leave unencoded in a `file:`
|
||||
/// URI (non-ASCII is always encoded); `%` stays, it starts the escapes already there.
|
||||
const LOOSE: &AsciiSet = &CONTROLS
|
||||
.add(b' ')
|
||||
.add(b'"')
|
||||
.add(b'<')
|
||||
.add(b'>')
|
||||
.add(b'[')
|
||||
.add(b'\\')
|
||||
.add(b']')
|
||||
.add(b'^')
|
||||
.add(b'`')
|
||||
.add(b'{')
|
||||
.add(b'|')
|
||||
.add(b'}');
|
||||
|
||||
/// Percent-encodes the characters URIs don't allow in every `file:` URI in `value`, string
|
||||
/// values and object keys alike (a workspace edit's `changes`). Eclipse's jdtls sends a path
|
||||
/// as is (`file:///H:/项目/…`), which `lsp_types::Uri` rejects, failing the whole response.
|
||||
pub fn encode_loose_file_uris(value: &mut Value) {
|
||||
match value {
|
||||
Value::String(s) => {
|
||||
if let Some(encoded) = encode_loose(s) {
|
||||
*s = encoded;
|
||||
}
|
||||
}
|
||||
Value::Array(items) => items.iter_mut().for_each(encode_loose_file_uris),
|
||||
Value::Object(map) => {
|
||||
if map.keys().any(|k| encode_loose(k).is_some()) {
|
||||
*map = std::mem::take(map).into_iter().map(|(k, v)| (encode_loose(&k).unwrap_or(k), v)).collect();
|
||||
}
|
||||
map.values_mut().for_each(encode_loose_file_uris);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn encode_loose(s: &str) -> Option<String> {
|
||||
if !s.get(..5).is_some_and(|scheme| scheme.eq_ignore_ascii_case("file:")) {
|
||||
return None;
|
||||
}
|
||||
match Cow::from(utf8_percent_encode(s, LOOSE)) {
|
||||
Cow::Owned(encoded) => Some(encoded),
|
||||
Cow::Borrowed(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn path_to_uri_string(path: &Path) -> String {
|
||||
let s = if cfg!(windows) {
|
||||
dunce::simplified(path).to_string_lossy().replace('\\', "/")
|
||||
@@ -95,6 +144,28 @@ pub use ide_core::text::is_virtual_uri;
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn file_uris_a_server_leaves_unencoded_are_encoded() {
|
||||
// jdtls on a project under a Chinese folder (`java.usages` / references response).
|
||||
let mut v = serde_json::json!({ "result": [{
|
||||
"location": { "uri": "file:///H:/项目/online disk/A.java", "range": { "start": { "line": 1, "character": 2 }, "end": { "line": 1, "character": 3 } } },
|
||||
"kind": "unknown"
|
||||
}], "edit": { "changes": { "file:///tmp/目录/b.java": [] } }, "text": "项目" });
|
||||
let raw = v["result"][0]["location"].clone();
|
||||
assert!(serde_json::from_value::<lsp_types::Location>(raw).is_err(), "lsp-types rejects it as sent");
|
||||
encode_loose_file_uris(&mut v);
|
||||
let uri = v["result"][0]["location"]["uri"].as_str().unwrap();
|
||||
assert_eq!(uri, "file:///H:/%E9%A1%B9%E7%9B%AE/online%20disk/A.java");
|
||||
let location: lsp_types::Location = serde_json::from_value(v["result"][0]["location"].clone()).unwrap();
|
||||
assert!(uri_to_path(location.uri.as_str()).unwrap().ends_with("项目/online disk/A.java"));
|
||||
assert!(v["edit"]["changes"].get("file:///tmp/%E7%9B%AE%E5%BD%95/b.java").is_some());
|
||||
assert_eq!(v["text"], "项目", "only file: URIs change");
|
||||
// Already encoded: untouched.
|
||||
let mut encoded = serde_json::json!("file:///a%20b/%E9%A1%B9.java");
|
||||
encode_loose_file_uris(&mut encoded);
|
||||
assert_eq!(encoded, "file:///a%20b/%E9%A1%B9.java");
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn round_trip() {
|
||||
|
||||
@@ -65,5 +65,26 @@ fn bench(c: &mut Criterion) {
|
||||
g.finish();
|
||||
}
|
||||
|
||||
criterion_group!(benches, bench);
|
||||
// No .ignore file: the query's subtree masks must prevent traversal themselves.
|
||||
fn excluded_subtrees(c: &mut Criterion) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
for module in 0..100 {
|
||||
let root = dir.path().join(format!("modules/m{module}"));
|
||||
std::fs::create_dir_all(root.join("src")).unwrap();
|
||||
std::fs::write(root.join("src/main.go"), "needle").unwrap();
|
||||
for dependency in 0..50 {
|
||||
let dep = root.join(format!("node_modules/dep{dependency}/lib"));
|
||||
std::fs::create_dir_all(&dep).unwrap();
|
||||
std::fs::write(dep.join("index.js"), "needle").unwrap();
|
||||
}
|
||||
}
|
||||
let q = SearchQuery { exclude: vec!["**/node_modules/**".into()], ..query("needle", false) };
|
||||
assert_eq!(run(dir.path(), &q), 100);
|
||||
let mut group = c.benchmark_group("search_excluded_subtrees");
|
||||
group.sample_size(15);
|
||||
group.bench_function("5k_dependencies", |b| b.iter(|| black_box(run(dir.path(), &q))));
|
||||
group.finish();
|
||||
}
|
||||
|
||||
criterion_group!(benches, bench, excluded_subtrees);
|
||||
criterion_main!(benches);
|
||||
@@ -143,18 +143,22 @@ pub(crate) fn run(req: Request<'_>) -> IdeResult<SearchSummary> {
|
||||
}
|
||||
|
||||
if !ctx.ctl.should_stop() {
|
||||
walk_files(&on_disk, || {
|
||||
let mut searcher = searcher_builder.build();
|
||||
let matcher = matcher.clone();
|
||||
let ctx = &ctx;
|
||||
Box::new(move |path| {
|
||||
if ctx.ctl.should_stop() {
|
||||
return WalkState::Quit;
|
||||
}
|
||||
ctx.search_file(path, &matcher, &mut searcher);
|
||||
if ctx.ctl.stopped() { WalkState::Quit } else { WalkState::Continue }
|
||||
})
|
||||
});
|
||||
walk_files(
|
||||
&on_disk,
|
||||
&|path| ctx.mask.has_directory_exclusions() && ctx.mask.excludes_dir(&rel_path(ctx.root, path)),
|
||||
|| {
|
||||
let mut searcher = searcher_builder.build();
|
||||
let matcher = matcher.clone();
|
||||
let ctx = &ctx;
|
||||
Box::new(move |path| {
|
||||
if ctx.ctl.should_stop() {
|
||||
return WalkState::Quit;
|
||||
}
|
||||
ctx.search_file(path, &matcher, &mut searcher);
|
||||
if ctx.ctl.stopped() { WalkState::Quit } else { WalkState::Continue }
|
||||
})
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
let cancelled = ctx.ctl.cancelled.load(Relaxed) || req.cancel.is_cancelled();
|
||||
@@ -176,7 +180,11 @@ pub(crate) type VisitFile<'s> = Box<dyn FnMut(&Path) -> WalkState + Send + 's>;
|
||||
/// them, while ignored files elsewhere (`.env`) and hidden files and folders
|
||||
/// (`.github`, `.eslintrc`) are visited. `.git`, symlinks and archives (jar,
|
||||
/// zip: browsed, not searched) are never visited.
|
||||
pub(crate) fn walk_files<'s>(roots: &[PathBuf], mut visitor: impl FnMut() -> VisitFile<'s> + Send) {
|
||||
pub(crate) fn walk_files<'s>(
|
||||
roots: &[PathBuf],
|
||||
skip_dir: &'s (dyn Fn(&Path) -> bool + Sync),
|
||||
mut visitor: impl FnMut() -> VisitFile<'s> + Send,
|
||||
) {
|
||||
let Some((first, rest)) = roots.split_first() else { return };
|
||||
let mut walk = WalkBuilder::new(first);
|
||||
for path in rest {
|
||||
@@ -204,6 +212,9 @@ pub(crate) fn walk_files<'s>(roots: &[PathBuf], mut visitor: impl FnMut() -> Vis
|
||||
};
|
||||
let Some(file_type) = entry.file_type() else { return WalkState::Continue };
|
||||
if file_type.is_dir() {
|
||||
if skip_dir(entry.path()) {
|
||||
return WalkState::Skip;
|
||||
}
|
||||
// The walker drops ignored files unseen, so the files of every walked
|
||||
// directory come from listing it; the walker only picks the directories.
|
||||
let Ok(children) = std::fs::read_dir(entry.path()) else { return WalkState::Continue };
|
||||
@@ -595,3 +606,39 @@ mod tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod walk_tests {
|
||||
use super::*;
|
||||
use std::sync::Mutex;
|
||||
|
||||
#[test]
|
||||
fn excluded_subtree_is_not_visited() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
std::fs::create_dir_all(root.join("edge/device/build/deep")).unwrap();
|
||||
std::fs::create_dir_all(root.join("edge/device/src")).unwrap();
|
||||
std::fs::write(root.join("edge/device/build/deep/generated.go"), "hit").unwrap();
|
||||
std::fs::write(root.join("edge/device/src/main.go"), "hit").unwrap();
|
||||
let mask = FileMask::new(&[], &["**/build/**".into()]).unwrap();
|
||||
let seen = Mutex::new(Vec::new());
|
||||
walk_files(&[root.to_path_buf()], &|path| mask.excludes_dir(&rel_path(root, path)), || {
|
||||
let seen = &seen;
|
||||
Box::new(move |path| {
|
||||
// No file-level mask here: a visit means the walker entered the subtree.
|
||||
seen.lock().unwrap().push(rel_path(root, path));
|
||||
WalkState::Continue
|
||||
})
|
||||
});
|
||||
assert_eq!(*seen.lock().unwrap(), ["edge/device/src/main.go"]);
|
||||
seen.lock().unwrap().clear();
|
||||
walk_files(&[root.join("edge/device/build/deep")], &|path| mask.excludes_dir(&rel_path(root, path)), || {
|
||||
let seen = &seen;
|
||||
Box::new(move |path| {
|
||||
seen.lock().unwrap().push(rel_path(root, path));
|
||||
WalkState::Continue
|
||||
})
|
||||
});
|
||||
assert!(seen.lock().unwrap().is_empty());
|
||||
}
|
||||
}
|
||||
@@ -43,7 +43,7 @@ pub fn scope_files(
|
||||
on_disk.push(path);
|
||||
}
|
||||
}
|
||||
walk_files(&on_disk, || {
|
||||
walk_files(&on_disk, &|path| mask.has_directory_exclusions() && mask.excludes_dir(&rel_path(root, path)), || {
|
||||
let found = &found;
|
||||
let keep = &keep;
|
||||
Box::new(move |path| {
|
||||
|
||||
@@ -12,6 +12,7 @@ pub struct FileMask {
|
||||
exclude_name: GlobSet,
|
||||
exclude_path: GlobSet,
|
||||
has_include: bool,
|
||||
exclude_dirs: GlobSet,
|
||||
}
|
||||
|
||||
impl FileMask {
|
||||
@@ -20,6 +21,7 @@ impl FileMask {
|
||||
pub fn new(include: &[String], exclude: &[String]) -> IdeResult<Self> {
|
||||
let mut inc = Lists::default();
|
||||
let mut exc = Lists::default();
|
||||
let mut dirs = Lists::default();
|
||||
for (entries, is_include_list) in [(include, true), (exclude, false)] {
|
||||
for mask in entries.iter().flat_map(|e| e.split(',')) {
|
||||
let mask = mask.trim();
|
||||
@@ -32,10 +34,20 @@ impl FileMask {
|
||||
}
|
||||
let target = if is_include_list != negated { &mut inc } else { &mut exc };
|
||||
target.push(mask)?;
|
||||
// Only a trailing /** guarantees that every descendant is excluded.
|
||||
// File masks and inclusion masks cannot safely prune a directory.
|
||||
if is_include_list == negated
|
||||
&& !mask.contains('\\')
|
||||
&& let Some(prefix) = mask.strip_suffix("/**")
|
||||
&& !prefix.is_empty()
|
||||
{
|
||||
dirs.push(&format!("{prefix}/"))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Self {
|
||||
has_include: inc.count > 0,
|
||||
exclude_dirs: dirs.path.build().map_err(glob_error)?,
|
||||
include_name: inc.name.build().map_err(glob_error)?,
|
||||
include_path: inc.path.build().map_err(glob_error)?,
|
||||
exclude_name: exc.name.build().map_err(glob_error)?,
|
||||
@@ -43,6 +55,20 @@ impl FileMask {
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn has_directory_exclusions(&self) -> bool {
|
||||
!self.exclude_dirs.is_empty()
|
||||
}
|
||||
|
||||
/// Whether an exclusion covers every file below this directory. This is
|
||||
/// deliberately conservative; ordinary masks still filter individual files.
|
||||
pub(crate) fn excludes_dir(&self, rel_path: &str) -> bool {
|
||||
if self.exclude_dirs.is_empty() {
|
||||
return false;
|
||||
}
|
||||
let path = format!("{rel_path}/");
|
||||
path.match_indices('/').any(|(i, _)| self.exclude_dirs.is_match(&path[..=i]))
|
||||
}
|
||||
|
||||
/// `rel_path` uses `/` separators.
|
||||
pub fn matches(&self, rel_path: &str) -> bool {
|
||||
let name = rel_path.rsplit('/').next().unwrap_or(rel_path);
|
||||
@@ -133,6 +159,60 @@ mod tests {
|
||||
assert!(!m.matches("Cargo.lock"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_complete_subtree_exclusions_prune_directories() {
|
||||
let m = mask(&["*.go"], &["**/node_modules/**", "edge/device/build/**"]);
|
||||
for dir in [
|
||||
"node_modules",
|
||||
"edge/node_modules",
|
||||
"edge/device/build",
|
||||
"edge/device/build/deep",
|
||||
"edge/node_modules/pkg/lib",
|
||||
] {
|
||||
assert!(m.excludes_dir(dir), "{dir}");
|
||||
}
|
||||
for dir in ["edge", "edge/device", "internal/build", "src.go"] {
|
||||
assert!(!m.excludes_dir(dir), "{dir}");
|
||||
}
|
||||
for pattern in ["*.go", "build", "build/*", "build/", "build/**/*.go"] {
|
||||
assert!(!mask(&[], &[pattern]).excludes_dir("build"), "{pattern}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn directory_pruning_preserves_mask_negation_semantics() {
|
||||
assert!(mask(&["!vendor/**"], &[]).excludes_dir("vendor"));
|
||||
assert!(!mask(&[], &["!vendor/**"]).excludes_dir("vendor"));
|
||||
// Exclusions already win over inclusions in FileMask, irrespective of order.
|
||||
let m = mask(&["vendor/keep.go"], &["vendor/**"]);
|
||||
assert!(m.excludes_dir("vendor"));
|
||||
assert!(!m.matches("vendor/keep.go"));
|
||||
assert!(mask(&[], &["./vendor/**, **/node_modules/**"]).excludes_dir("vendor"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn directory_pruning_uses_the_same_case_rules_as_files() {
|
||||
let m = mask(&[], &["Vendor/**"]);
|
||||
let case_insensitive = cfg!(any(target_os = "macos", target_os = "windows"));
|
||||
assert_eq!(m.excludes_dir("vendor"), case_insensitive);
|
||||
assert_eq!(m.matches("vendor/a.go"), !case_insensitive);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pruned_directory_descendants_are_already_excluded() {
|
||||
for pattern in ["vendor/**", "**/build/**", "modules/*/build/**", "[ab]/**", "**/**"] {
|
||||
let m = mask(&[], &[pattern]);
|
||||
for dir in ["vendor", "vendor/deep", "build", "a", "modules/a/build", "modules/a/src", "x/build/y"] {
|
||||
if m.excludes_dir(dir) {
|
||||
for file in ["main.go", "deep/lib.go", ".hidden/config", "node_modules/a.js"] {
|
||||
assert!(!m.matches(&format!("{dir}/{file}")), "{pattern}: {dir}/{file}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(!mask(&[], &[r"escaped\*/**"]).excludes_dir("escaped*"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_glob() {
|
||||
let err = FileMask::new(&["a[".into()], &[]).unwrap_err();
|
||||
|
||||
@@ -797,3 +797,42 @@ fn search_context_reads_non_utf8_files() {
|
||||
let p = project(&[("a.rs", &gbk("foo(\"新增\"); // 中文 foo\n"))]);
|
||||
assert_eq!(run_context(p.path(), C::InComments), vec![("a.rs".to_owned(), 0, vec![(17, 20)])]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subtree_masks_preserve_results_across_search_scopes() {
|
||||
let p = project(&[
|
||||
("edge/build/deep/generated.go", b"hit"),
|
||||
("edge/src/main.go", b"hit"),
|
||||
("internal/build/build.go", b"hit"),
|
||||
("edge/build-notes.go", b"hit"),
|
||||
]);
|
||||
let q = SearchQuery { exclude: vec!["edge/build/**".into()], ..query("hit") };
|
||||
let (views, _) = run(p.path(), &q);
|
||||
assert_eq!(paths(&views), ["edge/build-notes.go", "edge/src/main.go", "internal/build/build.go"]);
|
||||
let mask = ide_search::FileMask::new(&q.include, &q.exclude).unwrap();
|
||||
for scope in [
|
||||
SearchScope::Directory { path: "edge/build".into() },
|
||||
SearchScope::Files { paths: vec!["edge/build/deep/generated.go".into()] },
|
||||
] {
|
||||
let (views, _) = run(p.path(), &SearchQuery { scope: scope.clone(), ..q.clone() });
|
||||
assert!(views.is_empty());
|
||||
assert!(ide_search::scope_files(p.path(), &scope, &mask, None, &CancellationToken::new()).unwrap().is_empty());
|
||||
}
|
||||
// A file-name exclusion must not prune a same-named directory.
|
||||
let (views, _) = run(p.path(), &SearchQuery { exclude: vec!["build".into()], ..query("hit") });
|
||||
assert_eq!(views.len(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignore_whitelists_do_not_override_explicit_subtree_masks() {
|
||||
let p = project(&[
|
||||
(".gitignore", b"generated/*\n!generated/keep/\n"),
|
||||
("generated/keep/.gitignore", b"!keep.go\n"),
|
||||
("generated/keep/keep.go", b"needle"),
|
||||
("src/main.go", b"needle"),
|
||||
]);
|
||||
let (views, _) = run(p.path(), &query("needle"));
|
||||
assert_eq!(paths(&views), ["generated/keep/keep.go", "src/main.go"]);
|
||||
let (views, _) = run(p.path(), &SearchQuery { exclude: vec!["generated/**".into()], ..query("needle") });
|
||||
assert_eq!(paths(&views), ["src/main.go"]);
|
||||
}
|
||||
@@ -1410,10 +1410,16 @@ impl Tools {
|
||||
.ok_or_else(|| IdeError::new(ErrorKind::Io, format!("`{main}` was not found in {}", dl.name)))?;
|
||||
let rel = found.strip_prefix(&pkg).expect("inside pkg").to_path_buf();
|
||||
let final_dir = self.root.join(spec.name);
|
||||
if final_dir.exists() {
|
||||
std::fs::remove_dir_all(&final_dir)?;
|
||||
}
|
||||
std::fs::rename(&pkg, &final_dir)?;
|
||||
// Downloads made by the IDE itself are not quarantined, but archives may carry the flag.
|
||||
clear_quarantine(&pkg);
|
||||
// The previous install is removed in the background once replaced: deleting a large
|
||||
// tool takes a while, and there is nothing left to cancel by then.
|
||||
let previous = self.root.join(format!(".previous-{}", spec.name));
|
||||
let _ = std::fs::remove_dir_all(&previous);
|
||||
put_in_place(&pkg, &final_dir, &previous, cancel)?;
|
||||
std::thread::spawn(move || {
|
||||
let _ = std::fs::remove_dir_all(previous);
|
||||
});
|
||||
let target = final_dir.join(&rel);
|
||||
let bin = final_dir.join("bin");
|
||||
if is_bundle(main) {
|
||||
@@ -1428,8 +1434,6 @@ impl Tools {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
}
|
||||
}
|
||||
// Downloads made by the IDE itself are not quarantined, but archives may carry the flag.
|
||||
clear_quarantine(&final_dir);
|
||||
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
|
||||
}
|
||||
|
||||
@@ -1563,6 +1567,25 @@ fn fetch_verified(
|
||||
}
|
||||
|
||||
/// Removes the quarantine flag archives may carry, so macOS runs what was unpacked.
|
||||
/// Moves the unpacked `pkg` to `dest`, moving a previous install aside to `aside`.
|
||||
/// Cancelling stops it until then: the last point where the previous install is untouched.
|
||||
fn put_in_place(pkg: &Path, dest: &Path, aside: &Path, cancel: &CancellationToken) -> IdeResult<()> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let replaced = dest.exists();
|
||||
if replaced {
|
||||
std::fs::rename(dest, aside)?;
|
||||
}
|
||||
if let Err(e) = std::fs::rename(pkg, dest) {
|
||||
if replaced {
|
||||
let _ = std::fs::rename(aside, dest);
|
||||
}
|
||||
return Err(e.into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn clear_quarantine(dir: &Path) {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
|
||||
@@ -916,3 +916,22 @@ exit 1
|
||||
let args = fs::read_to_string(log).unwrap();
|
||||
assert!(args.contains(&format!("--python {}", sdk.join("python3.14").display())), "{args}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_cancelled_install_leaves_the_previous_one_in_place() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let (pkg, dest, aside) = (tmp.path().join("pkg"), tmp.path().join("tool"), tmp.path().join(".previous-tool"));
|
||||
fs::create_dir_all(&pkg).unwrap();
|
||||
fs::write(pkg.join("new"), "").unwrap();
|
||||
fs::create_dir_all(&dest).unwrap();
|
||||
fs::write(dest.join("old"), "").unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
cancel.cancel();
|
||||
let err = put_in_place(&pkg, &dest, &aside, &cancel).unwrap_err();
|
||||
assert_eq!(err.kind, ErrorKind::Cancelled);
|
||||
assert!(dest.join("old").exists() && pkg.join("new").exists() && !aside.exists());
|
||||
|
||||
put_in_place(&pkg, &dest, &aside, &CancellationToken::new()).unwrap();
|
||||
assert!(dest.join("new").exists() && !dest.join("old").exists());
|
||||
assert!(aside.join("old").exists(), "the previous install is moved aside");
|
||||
}
|
||||
@@ -95,9 +95,12 @@ import { readFileLines, withDocument } from "@/editor/lsp/files";
|
||||
import { pathToCopy } from "@/platform/copyPath";
|
||||
import { shortcutLabel } from "@/platform/keymap";
|
||||
|
||||
/** Text-editing actions: the editor has focus, or a popup (Find Action) runs them on it. */
|
||||
export const TEXT_WHEN = "editorTextFocus || textEditorActive && popupOpen";
|
||||
const EDITOR_WHEN = "textEditorActive && (editorFocus || popupOpen || !toolWindowFocus)";
|
||||
/**
|
||||
* Text-editing actions: the editor has focus, or a popup (Find Action) runs them on it. Not a
|
||||
* tool window's speed search: it opens a layer too, but the keys belong to its tree (⌘⌫).
|
||||
*/
|
||||
export const TEXT_WHEN = "editorTextFocus || textEditorActive && popupOpen && !toolWindowFocus";
|
||||
const EDITOR_WHEN = "textEditorActive && (editorFocus || !toolWindowFocus)";
|
||||
const TABS_WHEN = "editorTabsOpen && !toolWindowFocus";
|
||||
|
||||
function activeSlot(): EditorSlot | null {
|
||||
@@ -666,7 +669,7 @@ export function registerEditorActions(): () => void {
|
||||
id,
|
||||
title,
|
||||
category: "Edit",
|
||||
when: `${TEXT_WHEN} || findBarFocus || findBarOpen && popupOpen`,
|
||||
when: `${TEXT_WHEN} || findBarFocus || findBarOpen && popupOpen && !toolWindowFocus`,
|
||||
run: ({ arg, ctx }) => {
|
||||
const view = typeof arg === "string" || ctx.findBarFocus ? findPanelTarget(arg)?.view() : null;
|
||||
if (view) {
|
||||
|
||||
@@ -9,9 +9,10 @@ import { registerActions } from "@/platform/actions";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { useRemote } from "@/platform/remote";
|
||||
import { hideContextMenu, resolveMenuItems, useContextMenuStore } from "@/ui";
|
||||
import { getContext, setContext } from "@/platform/context";
|
||||
import { evaluateWhen, getContext, setContext } from "@/platform/context";
|
||||
import { installKeyboardDispatcher } from "@/platform/keymap";
|
||||
import { TEXT_WHEN } from "./actions";
|
||||
import { EDITOR_WHEN } from "@/editor/lsp/actions";
|
||||
|
||||
let ctrl: EditorController | null = null;
|
||||
|
||||
@@ -464,3 +465,21 @@ describe("EditorController", () => {
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("editor action when clauses", () => {
|
||||
const editorBehind = { textEditorActive: true, editorTextFocus: false, editorFocus: false, popupOpen: true };
|
||||
|
||||
it.each([
|
||||
["TEXT_WHEN", TEXT_WHEN],
|
||||
["EDITOR_WHEN", EDITOR_WHEN],
|
||||
])("%s runs on the editor from a popup such as Find Action", (_, when) => {
|
||||
expect(evaluateWhen(when, { ...editorBehind, toolWindowFocus: false })).toBe(true);
|
||||
});
|
||||
|
||||
it.each([
|
||||
["TEXT_WHEN", TEXT_WHEN],
|
||||
["EDITOR_WHEN", EDITOR_WHEN],
|
||||
])("%s leaves keys to a tool window's speed search, e.g. ⌘⌫ to Delete Line", (_, when) => {
|
||||
expect(evaluateWhen(when, { ...editorBehind, toolWindowFocus: true })).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -30,7 +30,7 @@ import {
|
||||
import { evaluateWhen } from "@/platform/context";
|
||||
|
||||
/** Editor actions apply to the active text editor unless a tool window or popup owns the keyboard. */
|
||||
export const EDITOR_WHEN = "textEditorActive && (editorFocus || popupOpen || !toolWindowFocus)";
|
||||
export const EDITOR_WHEN = "textEditorActive && (editorFocus || !toolWindowFocus)";
|
||||
|
||||
/**
|
||||
* Languages whose servers offer Generate (constructors, accessors, overrides…).
|
||||
|
||||
@@ -63,6 +63,7 @@ import {
|
||||
SYNTAX_NOTE,
|
||||
declarationFallback,
|
||||
indexDefinitions,
|
||||
isDeclarationName,
|
||||
isSelfTarget,
|
||||
localHighlights,
|
||||
type DeclarationTarget,
|
||||
@@ -360,6 +361,15 @@ export async function gotoTargets(view: EditorView, kind: GotoKind, at?: number)
|
||||
}
|
||||
}
|
||||
|
||||
/** Whether the caret is on the name of a declaration, by the syntax tree (no language server wait). */
|
||||
async function onDeclarationName(view: EditorView, offset: number): Promise<boolean> {
|
||||
const doc = docOf(view);
|
||||
if (!doc) return false;
|
||||
const pos = offsetToPos(view.state.doc, offset);
|
||||
const at = await structure.nodeAt(doc.doc, { start: pos, end: pos }).catch(() => null);
|
||||
return isDeclarationName(at);
|
||||
}
|
||||
|
||||
async function gotoResolved(
|
||||
view: EditorView,
|
||||
kind: GotoKind,
|
||||
@@ -374,7 +384,10 @@ async function gotoResolved(
|
||||
const before = view.state.doc;
|
||||
const plugin = await contributedNavigation(view, offset).catch(() => null);
|
||||
if (view.state.doc !== before || superseded()) return;
|
||||
if (plugin) {
|
||||
// ⌘B on a declaration shows its usages, also when a plugin links the name elsewhere (a
|
||||
// MyBatis mapper method to its XML statement).
|
||||
if (plugin && !(kind === "definition" && (await onDeclarationName(view, offset)))) {
|
||||
if (superseded()) return;
|
||||
if (plugin.targets.length === 1) await navigateTo(plugin.targets[0]!);
|
||||
else {
|
||||
const items = await locationItems(plugin.targets);
|
||||
|
||||
@@ -45,6 +45,7 @@ provideEditorService({ openFile } as never);
|
||||
|
||||
const fb = await import("./syntaxFallback");
|
||||
const { gotoTargets, navigationExtension, highlightUsages } = await import("./navigation");
|
||||
const { registerNavigationProvider } = await import("@/editor/navigationProviders");
|
||||
const { startRename, renameNamePart } = await import("./rename");
|
||||
const { lspDoc } = await import("./lsp");
|
||||
const { invalidateConfigurationNavigation } = await import("./configurationNavigation");
|
||||
@@ -416,6 +417,48 @@ describe("navigation wiring", () => {
|
||||
expect(openFile).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("shows usages on a declaration a plugin's index links elsewhere, and follows the link from a call", async () => {
|
||||
// MyBatis Duo indexes the mapper method's name as a link to its XML statement.
|
||||
const xml = { path: "/p/UserMapper.xml", range: r(3, 16, 24) };
|
||||
const off = registerNavigationProvider(async (view) => {
|
||||
const at = view.state.doc.toString().indexOf("findName");
|
||||
return { from: at, to: at + 8, targets: [xml] };
|
||||
});
|
||||
try {
|
||||
// The syntax tree puts the caret on the method's name; the host then answers both.
|
||||
cmd.syntaxNodeAt.mockReturnValueOnce(
|
||||
ok({
|
||||
node: node("identifier", r(3, 11, 19), "name"),
|
||||
ancestors: [node("method_declaration", { start: { line: 3, col: 4 }, end: { line: 3, col: 29 } })],
|
||||
}),
|
||||
);
|
||||
cmd.lspGoto.mockReturnValueOnce(ok([xml, { path: "/p/UserMapper.java", range: r(3, 11, 19) }]));
|
||||
const view = editor(
|
||||
"package demo;\n\npublic interface UserMapper {\n String findName(Long id);\n}\n",
|
||||
"java",
|
||||
58,
|
||||
"/p/UserMapper.java",
|
||||
);
|
||||
await gotoTargets(view, "definition");
|
||||
expect(executeAction).toHaveBeenCalledWith("find.showUsages");
|
||||
expect(openFile).not.toHaveBeenCalled();
|
||||
|
||||
// A call: the plugin's link is followed without asking the language server.
|
||||
executeAction.mockClear();
|
||||
cmd.lspGoto.mockClear();
|
||||
cmd.syntaxNodeAt.mockReturnValueOnce(
|
||||
ok({ node: node("identifier", r(1, 26, 34), "name"), ancestors: [node("method_invocation", r(1, 24, 38))] }),
|
||||
);
|
||||
const call = editor("class S {\n void f(UserMapper m) { m.findName(1L); }\n}\n", "java", 37, "/p/S.java");
|
||||
await gotoTargets(call, "definition");
|
||||
expect(openFile).toHaveBeenCalledWith("/p/UserMapper.xml", expect.objectContaining({ focus: true }));
|
||||
expect(executeAction).not.toHaveBeenCalledWith("find.showUsages");
|
||||
expect(cmd.lspGoto).not.toHaveBeenCalled();
|
||||
} finally {
|
||||
off();
|
||||
}
|
||||
});
|
||||
|
||||
it("looks past a server answer that points at the import itself", async () => {
|
||||
cmd.lspGoto.mockReturnValueOnce(ok([{ path: "/p/a.py", range: r(0, 37, 43) }]));
|
||||
cmd.navIndexDefinitions.mockReturnValueOnce(ok([sym("logger", "variable", "/deps/torchtitan/tools/logging.py")]));
|
||||
|
||||
@@ -63,6 +63,14 @@ export function usageRole(at: NodeAt | null): UsageRole {
|
||||
return "other";
|
||||
}
|
||||
|
||||
const DECLARATION = /(declaration|definition|declarator)$/;
|
||||
|
||||
/** Whether the syntax tree puts the identifier at `at` as the name of a declaration (`int f()`'s `f`). */
|
||||
export function isDeclarationName(at: NodeAt | null): boolean {
|
||||
const parent = at?.ancestors[0];
|
||||
return !!parent && at.node.field === "name" && DECLARATION.test(parent.kind);
|
||||
}
|
||||
|
||||
/** Index symbols that may be the declaration of `name` used in `role`. */
|
||||
export function filterSymbols(matches: readonly SymbolMatch[], name: string, role: UsageRole): SymbolMatch[] {
|
||||
return matches.filter((m) => {
|
||||
|
||||
@@ -22,7 +22,7 @@ import { gotoTestOrSubject, type TestNavDeps } from "./gotoTest";
|
||||
import { baseName, memberAt, methodStop, superMethods } from "./structureNav";
|
||||
import { tx } from "@/platform/i18n";
|
||||
|
||||
const EDITOR_WHEN = "textEditorActive && (editorFocus || popupOpen || !toolWindowFocus)";
|
||||
const EDITOR_WHEN = "textEditorActive && (editorFocus || !toolWindowFocus)";
|
||||
|
||||
/** A backend document id for `path` while `fn` runs (open editors are reused). */
|
||||
async function withDoc<T>(path: string, fn: (doc: number) => Promise<T>): Promise<T> {
|
||||
|
||||
@@ -26,7 +26,7 @@ import { ServerStatus } from "./ServerStatus";
|
||||
import { reportProblems } from "./problemsReport";
|
||||
import { installWorkspaceEditUndo } from "./workspaceUndo";
|
||||
|
||||
const EDITOR_WHEN = "textEditorActive && (editorFocus || popupOpen || !toolWindowFocus)";
|
||||
const EDITOR_WHEN = "textEditorActive && (editorFocus || !toolWindowFocus)";
|
||||
|
||||
function useErrorBadge(): number | null {
|
||||
return useProblems((s) => {
|
||||
|
||||
@@ -5,6 +5,9 @@ import { executeAction } from "@/platform/actions";
|
||||
import { setContext } from "@/platform/context";
|
||||
import { registerDatabaseTreeActions } from "./treeActions";
|
||||
import { tablesKey, useDatabase } from "./store";
|
||||
import { tableInput } from "./tableInput";
|
||||
import { useEditorRegistry } from "@/editor/api";
|
||||
import { provideEditorService, provideToolWindowService, type EditorInput } from "@/workbench/contributions";
|
||||
|
||||
vi.mock("@tanstack/react-virtual", () => ({
|
||||
useVirtualizer: ({ count }: { count: number }) => ({
|
||||
@@ -108,6 +111,61 @@ describe("routine grouping", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("Select Opened File", () => {
|
||||
const nextFrame = () => act(() => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())));
|
||||
let active: EditorInput | null = null;
|
||||
const show = vi.fn();
|
||||
|
||||
beforeEach(() => {
|
||||
provideEditorService({ activeInput: () => active } as never);
|
||||
provideToolWindowService({ show } as never);
|
||||
useDatabase.setState({
|
||||
tables: {
|
||||
[tablesKey("pg", "public")]: {
|
||||
status: "ok",
|
||||
value: [
|
||||
{ name: "people", kind: "table" },
|
||||
{ name: "adults", kind: "view" },
|
||||
],
|
||||
},
|
||||
},
|
||||
schemas: { pg: { status: "ok", value: ["public", "audit"] } },
|
||||
treeExpanded: new Set(),
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
active = null;
|
||||
useEditorRegistry.setState({ active: null });
|
||||
});
|
||||
|
||||
it("selects the active table editor's view in the views folder", async () => {
|
||||
render(<DatabaseView />);
|
||||
active = tableInput("pg", "public", "adults");
|
||||
await act(() => executeAction("db.selectOpened"));
|
||||
await nextFrame();
|
||||
expect(useDatabase.getState().selectedNode?.key).toBe("pg/public/views/adults");
|
||||
expect(show).toHaveBeenCalledWith("database");
|
||||
expect(document.activeElement).toBe(screen.getByRole("tree", { name: "Data sources" }));
|
||||
});
|
||||
|
||||
it("selects the nearest shown ancestor of a dropped table, and a console's schema", async () => {
|
||||
render(<DatabaseView />);
|
||||
active = tableInput("pg", "public", "dropped");
|
||||
await act(() => executeAction("db.selectOpened"));
|
||||
await nextFrame();
|
||||
expect(useDatabase.getState().selectedNode?.key).toBe("pg/public/tables");
|
||||
|
||||
const path = "/project/audit.sql";
|
||||
useDatabase.setState({ consoles: { [path]: "pg" }, consoleSchemas: { [path]: "audit" } });
|
||||
active = { kind: "file", key: path, path };
|
||||
useEditorRegistry.setState({ active: { ctx: { path, language: "sql" } } as never });
|
||||
await act(() => executeAction("db.selectOpened"));
|
||||
await nextFrame();
|
||||
expect(useDatabase.getState().selectedNode?.key).toBe("pg/audit");
|
||||
});
|
||||
});
|
||||
|
||||
describe("Expand All", () => {
|
||||
it("opens every loaded node and leaves unloaded ones closed", async () => {
|
||||
useDatabase.setState({
|
||||
|
||||
@@ -143,12 +143,12 @@ export function DatabaseView() {
|
||||
useEffect(() => {
|
||||
if (!st.loaded) void loadSources();
|
||||
}, [st.loaded]);
|
||||
// Go to Declaration from a console: the rows exist once the expanded nodes render.
|
||||
// Go to Declaration from a console, Select Opened File: the rows exist once the expanded nodes render.
|
||||
useEffect(() => {
|
||||
if (!st.treeReveal) return;
|
||||
const key = st.treeReveal.key;
|
||||
const path = st.treeReveal.path;
|
||||
const frame = requestAnimationFrame(() => {
|
||||
tree.current?.reveal(key);
|
||||
path.toReversed().some((key) => tree.current?.reveal(key));
|
||||
tree.current?.focus();
|
||||
});
|
||||
return () => cancelAnimationFrame(frame);
|
||||
@@ -683,10 +683,11 @@ function DatabaseToolbar() {
|
||||
);
|
||||
}
|
||||
|
||||
/** Header controls (shown on hover, like IDEA's): Expand All, Collapse All. */
|
||||
/** Header controls (shown on hover, like IDEA's): Select Opened File, Expand All, Collapse All. */
|
||||
export function DatabaseHeaderActions() {
|
||||
return (
|
||||
<>
|
||||
<IconButton icon="locate" action="db.selectOpened" size="small" iconSize={16} />
|
||||
<IconButton icon="expand-all" action="db.expandAll" size="small" iconSize={16} />
|
||||
<IconButton icon="collapse-all" action="db.collapseAll" size="small" iconSize={16} />
|
||||
</>
|
||||
|
||||
@@ -25,9 +25,10 @@ import {
|
||||
type RequestId,
|
||||
type SqlStatement,
|
||||
} from "@/platform/ipc";
|
||||
import { editorsFor } from "@/editor/api";
|
||||
import { activeEditor, editorsFor } from "@/editor/api";
|
||||
import {
|
||||
editorService,
|
||||
maybeEditorService,
|
||||
notifications,
|
||||
showServiceView,
|
||||
toolWindowService,
|
||||
@@ -44,8 +45,11 @@ import {
|
||||
idleTargets,
|
||||
newSourceId,
|
||||
splitTarget,
|
||||
targetOf,
|
||||
} from "./model";
|
||||
import { tableFolder, type DbNode } from "./nodes";
|
||||
import { SQL_LANGUAGE } from "./sqlLanguage";
|
||||
import { TABLE_KIND, type TableRef } from "./tableInput";
|
||||
import type { ExportData, ExportFormat } from "./export";
|
||||
import type { DbObjectRef } from "./objects";
|
||||
import { formatted } from "./sql/format";
|
||||
@@ -180,7 +184,7 @@ interface DatabaseState {
|
||||
/** Expanded nodes of the Database tree. */
|
||||
treeExpanded: Set<string>;
|
||||
/** A tree node to select and scroll to (Go to Declaration from a console). */
|
||||
treeReveal: { key: string; seq: number } | null;
|
||||
treeReveal: { path: string[]; seq: number } | null;
|
||||
/** Last value entered per query parameter name. */
|
||||
paramValues: Record<string, string>;
|
||||
/** Data sources in manual-commit mode. */
|
||||
@@ -604,13 +608,14 @@ export async function loadDetails(id: string, schema: string, table: string): Pr
|
||||
|
||||
/**
|
||||
* Selects a table (or one of its columns) in the Database tool window,
|
||||
* loading and expanding the nodes that lead to it.
|
||||
* loading and expanding the nodes that lead to it. Without `kind` the loaded
|
||||
* tables tell whether it is a table or a view.
|
||||
*/
|
||||
export async function revealInTree(
|
||||
id: string,
|
||||
schema: string,
|
||||
table: string,
|
||||
kind: DbTableKind,
|
||||
kind: DbTableKind | undefined,
|
||||
column?: string,
|
||||
): Promise<void> {
|
||||
const loaded = (l: Loaded<unknown> | undefined) => l?.status === "ok";
|
||||
@@ -632,20 +637,64 @@ export async function revealInTree(
|
||||
if (!loaded(useDatabase.getState().tables[tablesKey(id, schema)])) await loadTables(id, schema);
|
||||
if (column && !loaded(useDatabase.getState().details[detailsKey(id, schema, table)]))
|
||||
await loadDetails(id, schema, table);
|
||||
const tables = useDatabase.getState().tables[tablesKey(id, schema)];
|
||||
kind ??= (tables?.status === "ok" ? tables.value.find((t) => t.name === table)?.kind : undefined) ?? "table";
|
||||
const folder = `${id}/${schema}/${tableFolder(kind)}`;
|
||||
const tableKey = `${folder}/${table}`;
|
||||
const open = [
|
||||
sourceId,
|
||||
...databaseNode,
|
||||
`${id}/${schema}`,
|
||||
folder,
|
||||
...(column ? [tableKey, `${tableKey}/columns`] : []),
|
||||
];
|
||||
selectInTree(
|
||||
[sourceId, ...databaseNode, `${id}/${schema}`, folder, ...(column ? [tableKey, `${tableKey}/columns`] : [])],
|
||||
column ? `${tableKey}/columns/${column}` : tableKey,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Expands `open` and selects node `key` in the Database tool window, showing it.
|
||||
* A node the tree doesn't show (filtered out, dropped) selects its nearest shown ancestor.
|
||||
*/
|
||||
function selectInTree(open: string[], key: string) {
|
||||
useDatabase.setState((s) => ({
|
||||
treeExpanded: new Set([...s.treeExpanded, ...open]),
|
||||
treeReveal: { key: column ? `${tableKey}/columns/${column}` : tableKey, seq: (s.treeReveal?.seq ?? 0) + 1 },
|
||||
treeReveal: { path: [...open, key], seq: (s.treeReveal?.seq ?? 0) + 1 },
|
||||
}));
|
||||
toolWindowService().show(DB_TOOL_WINDOW, true);
|
||||
// Not `show(…, true)`: activation focuses the filter field after the view focuses the tree.
|
||||
toolWindowService().show(DB_TOOL_WINDOW);
|
||||
}
|
||||
|
||||
/**
|
||||
* Select Opened File: the active table editor's table, else the schema (or
|
||||
* database / data source) a SQL console runs in. A console reveals only nodes
|
||||
* already loaded: it never connects.
|
||||
*/
|
||||
export async function revealOpened(): Promise<void> {
|
||||
const input = maybeEditorService()?.activeInput?.();
|
||||
if (input?.kind === TABLE_KIND) {
|
||||
const { id, schema, table } = input.data as TableRef;
|
||||
return revealInTree(id, schema, table, undefined);
|
||||
}
|
||||
const editor = activeEditor();
|
||||
if (editor?.ctx.language !== SQL_LANGUAGE || (input && input.path !== editor.ctx.path)) return;
|
||||
const target = consoleSource(editor.ctx.path);
|
||||
if (!target) return;
|
||||
const s = useDatabase.getState();
|
||||
const { id: sourceId, database } = splitTarget(target);
|
||||
const open: string[] = [];
|
||||
let key = sourceId;
|
||||
let nodeTarget = target;
|
||||
if (listsDatabases(sourceById(sourceId))) {
|
||||
const dbs = s.databases[sourceId];
|
||||
const name = database ?? (dbs?.status === "ok" ? dbs.value.current : null);
|
||||
if (dbs?.status !== "ok" || !name) return selectInTree(open, key);
|
||||
open.push(key);
|
||||
key = databaseKey(sourceId, name);
|
||||
nodeTarget = targetOf(sourceId, name, dbs.value.current);
|
||||
}
|
||||
const schema = consoleSchema(editor.ctx.path);
|
||||
const schemas = s.schemas[nodeTarget];
|
||||
if (schema && schemas?.status === "ok" && schemas.value.includes(schema)) {
|
||||
open.push(key);
|
||||
key = `${nodeTarget}/${schema}`;
|
||||
}
|
||||
selectInTree(open, key);
|
||||
}
|
||||
|
||||
const completionLoads = new Map<string, Promise<DbCompletion | null>>();
|
||||
|
||||
@@ -31,6 +31,7 @@ import {
|
||||
readableDdl,
|
||||
refresh,
|
||||
revealInTree,
|
||||
revealOpened,
|
||||
runSql,
|
||||
sourceById,
|
||||
tablesKey,
|
||||
@@ -485,6 +486,15 @@ export function registerDatabaseTreeActions(): () => void {
|
||||
title: "Separate Procedures and Functions",
|
||||
run: toggleSeparateProceduresAndFunctions,
|
||||
}),
|
||||
tree({
|
||||
id: "db.selectOpened",
|
||||
title: "Select Opened File",
|
||||
icon: "locate",
|
||||
keywords: ["locate", "scroll from editor", "scroll from source", "select in database view"],
|
||||
// From the editor: a user-assigned shortcut works outside the Database view too.
|
||||
keyWhen: undefined,
|
||||
run: () => void revealOpened(),
|
||||
}),
|
||||
tree({
|
||||
id: "db.expandAll",
|
||||
title: "Expand All",
|
||||
|
||||
@@ -25,7 +25,7 @@ import { loadEmmet } from "./emmet/model";
|
||||
import { promptAbbreviation, UpdateTagDialogHost } from "./emmet/UpdateTagDialog";
|
||||
import { tx } from "@/platform/i18n";
|
||||
|
||||
const EDITOR_WHEN = "textEditorActive && !editorReadOnly && (editorFocus || popupOpen || !toolWindowFocus)";
|
||||
const EDITOR_WHEN = "textEditorActive && !editorReadOnly && (editorFocus || !toolWindowFocus)";
|
||||
const MARKUP_PATH = /\.(html?|xhtml|shtml|vue|svelte|xml)$/i;
|
||||
|
||||
async function updateTagWithEmmet() {
|
||||
|
||||
@@ -223,7 +223,7 @@ it("renames in the project view although the preset shares Alt+Shift+R with the
|
||||
const dbRename = vi.fn();
|
||||
const refactorRename = vi.fn();
|
||||
// The claimants as they ship: `when` + `keyWhen` exactly as registered.
|
||||
const EDITOR = "textEditorActive && (editorFocus || popupOpen || !toolWindowFocus)";
|
||||
const EDITOR = "textEditorActive && (editorFocus || !toolWindowFocus)";
|
||||
const disposers = [
|
||||
registerAction({
|
||||
id: "project.rename",
|
||||
|
||||
@@ -404,6 +404,7 @@ export const intellijMacos: Record<string, string[]> = {
|
||||
"db.runSqlScript": [],
|
||||
"db.sqlScript": [],
|
||||
"db.goToReferencedTable": [],
|
||||
"db.selectOpened": [],
|
||||
"db.expandAll": [],
|
||||
"db.collapseAll": [],
|
||||
// Terminal (keyWhen: terminalFocus); after VCS Update / Go to Test so it wins there.
|
||||
|
||||
@@ -402,6 +402,7 @@ export const intellijWindows: Record<string, string[]> = {
|
||||
"db.runSqlScript": [],
|
||||
"db.sqlScript": [],
|
||||
"db.goToReferencedTable": [],
|
||||
"db.selectOpened": [],
|
||||
"db.expandAll": [],
|
||||
"db.collapseAll": [],
|
||||
// Terminal (keyWhen: terminalFocus); after VCS Update / Go to Test so it wins there.
|
||||
|
||||
@@ -392,6 +392,7 @@ export const vscodeMacos: Record<string, string[]> = {
|
||||
"db.runSqlScript": [],
|
||||
"db.sqlScript": [],
|
||||
"db.goToReferencedTable": [],
|
||||
"db.selectOpened": [],
|
||||
"db.expandAll": [],
|
||||
"db.collapseAll": [],
|
||||
// Find in Files popup (findPopupOpen): after the editor's keys, so these win while it is open.
|
||||
|
||||
@@ -3,6 +3,8 @@ import { createRef } from "react";
|
||||
import { act, fireEvent, render, screen, within } from "@testing-library/react";
|
||||
import { Tree, type TreeHandle } from "./Tree";
|
||||
import { getContext } from "@/platform/context";
|
||||
import { registerAction } from "@/platform/actions";
|
||||
import { installKeyboardDispatcher, useKeymap } from "@/platform/keymap";
|
||||
|
||||
interface N {
|
||||
id: string;
|
||||
@@ -251,6 +253,30 @@ describe("Tree speed search", () => {
|
||||
expect(labels(tree)).toContain("App.tsx");
|
||||
});
|
||||
|
||||
it("⌘⌫ erases the query and ⌥⌫ its last word instead of running the view's ⌘⌫ action", () => {
|
||||
const drop = vi.fn();
|
||||
useKeymap.setState({ preset: "intellij-macos", overrides: { "test.drop": ["Meta+Backspace", "Alt+Backspace"] } });
|
||||
const dispose = [registerAction({ id: "test.drop", title: "Drop", run: drop }), installKeyboardDispatcher()];
|
||||
try {
|
||||
const { tree, lead, key } = setup({ defaultExpanded: ["src", "main"] });
|
||||
key("ArrowDown");
|
||||
for (const c of "index.t") key(c);
|
||||
expect(lead()).toBe("index.ts");
|
||||
key("Backspace", { altKey: true });
|
||||
expect(screen.getByRole("status")).toHaveTextContent(/^index\.$/);
|
||||
key("Backspace", { metaKey: true });
|
||||
expect(screen.queryByRole("status")).toBeNull();
|
||||
expect(drop).not.toHaveBeenCalled();
|
||||
// Without a query the shortcut reaches the view again.
|
||||
key("Backspace", { metaKey: true });
|
||||
expect(drop).toHaveBeenCalledOnce();
|
||||
expect(tree).toHaveFocus();
|
||||
} finally {
|
||||
dispose.forEach((d) => d());
|
||||
useKeymap.setState({ overrides: {} });
|
||||
}
|
||||
});
|
||||
|
||||
it("filter mode hides non-matching rows but keeps ancestors", () => {
|
||||
const { tree, key } = setup({ defaultExpanded: ["src", "main"], speedSearchMode: "filter" });
|
||||
key("ArrowDown");
|
||||
|
||||
+17
-6
@@ -31,6 +31,7 @@ import { acquirePopup } from "./popupState";
|
||||
import styles from "./Tree.module.css";
|
||||
import { T } from "./T";
|
||||
import { setContext } from "@/platform/context";
|
||||
import { registerKeyClaim } from "@/platform/keymap";
|
||||
import { useGivenTx } from "@/platform/i18n";
|
||||
import { useTreeReorder, type TreeReorder } from "./treeReorder";
|
||||
import { startPointerDrag, type DragData } from "./pointerDrag";
|
||||
@@ -61,8 +62,8 @@ export interface TreeOccurrence {
|
||||
|
||||
export interface TreeHandle {
|
||||
focus(): void;
|
||||
/** Selects `key` (must be visible, i.e. ancestors expanded) and scrolls to it. */
|
||||
reveal(key: string): void;
|
||||
/** Selects `key` (must be visible, i.e. ancestors expanded) and scrolls to it; false when no row has `key`. */
|
||||
reveal(key: string): boolean;
|
||||
leadKey(): string | null;
|
||||
/** Selects the next (1) / previous (-1) row, for a filter field that keeps the focus (Settings search). */
|
||||
moveSelection(dir: 1 | -1): void;
|
||||
@@ -367,10 +368,18 @@ export function Tree<T>(props: TreeProps<T>) {
|
||||
pendingScrollToLead.current = null;
|
||||
}, [lead, indexOfKey, virtualizer]);
|
||||
|
||||
// Speed search owns Escape while active.
|
||||
// Speed search owns Escape while active, and ⌫ with any modifier: the query is edited like a
|
||||
// text field instead of the view's shortcuts running (⌘⌫ is Drop… in the Database view).
|
||||
useEffect(() => {
|
||||
if (!query) return;
|
||||
return acquirePopup();
|
||||
const release = acquirePopup();
|
||||
const unclaim = registerKeyClaim(
|
||||
(e) => e.key === "Backspace" && e.target instanceof Node && !!scrollRef.current?.contains(e.target),
|
||||
);
|
||||
return () => {
|
||||
release();
|
||||
unclaim();
|
||||
};
|
||||
}, [query]);
|
||||
|
||||
const setExpanded = (row: Row<T>, open: boolean) => {
|
||||
@@ -420,10 +429,11 @@ export function Tree<T>(props: TreeProps<T>) {
|
||||
focus: () => scrollRef.current?.focus(),
|
||||
reveal: (key: string) => {
|
||||
const i = indexOfKey.get(key);
|
||||
if (i === undefined) return;
|
||||
if (i === undefined) return false;
|
||||
setAnchor(key);
|
||||
commitSelection(new Set([key]), key);
|
||||
virtualizer.scrollToIndex(i, { align: "center" });
|
||||
return true;
|
||||
},
|
||||
leadKey: () => lead,
|
||||
moveSelection: (dir: 1 | -1) => {
|
||||
@@ -523,7 +533,8 @@ export function Tree<T>(props: TreeProps<T>) {
|
||||
break;
|
||||
case "Backspace":
|
||||
if (!query) return;
|
||||
setQuery(query.slice(0, -1));
|
||||
// ⌘⌫ erases the query, ⌥⌫ / Ctrl+⌫ its last word, as in a text field.
|
||||
setQuery(e.metaKey ? "" : e.altKey || e.ctrlKey ? query.replace(/\w*\W*$/, "") : query.slice(0, -1));
|
||||
break;
|
||||
case "ArrowDown":
|
||||
case "ArrowUp": {
|
||||
|
||||
@@ -179,6 +179,7 @@ const ICONS = {
|
||||
"file-asciidoc": "openidea/fileTypes/asciidoc",
|
||||
"file-d": "openidea/fileTypes/d",
|
||||
"file-prisma": "openidea/fileTypes/prisma",
|
||||
"file-slint": "openidea/fileTypes/slint",
|
||||
"file-dart": "openidea/fileTypes/dart",
|
||||
"file-elixir": "openidea/fileTypes/elixir",
|
||||
"file-erlang": "openidea/fileTypes/erlang",
|
||||
@@ -1107,6 +1108,7 @@ const EXT_ICONS = table({
|
||||
"file-asciidoc": "adoc asciidoc",
|
||||
"file-d": "d di",
|
||||
"file-prisma": "prisma",
|
||||
"file-slint": "slint",
|
||||
"file-dart": "dart",
|
||||
"file-elixir": "ex exs",
|
||||
"file-erlang": "erl hrl escript app.src",
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
|
||||
<g stroke-linejoin="round"><path d="M14 4C14 2.89543 13.1046 2 12 2H4C2.89543 2 2 2.89543 2 4V12C2 13.1046 2.89543 14 4 14H12C13.1046 14 14 13.1046 14 12V4Z" fill="#2379F4"/><path transform="translate(5 3.5)" d="M5.5 1.6C5.1 0.9 4.3 0.5 3.4 0.5H2.6C1.4 0.5 0.5 1.3 0.5 2.4C0.5 3.5 1.3 3.9 2.5 4.2L3.5 4.4C4.7 4.7 5.5 5.1 5.5 6.3C5.5 7.5 4.6 8.5 3.4 8.5H2.6C1.6 8.5 0.9 8 0.5 7.4" stroke="#2B2D30"/></g>
|
||||
</svg>
|
||||
|
Після Ширина: | Висота: | Розмір: 506 B |
@@ -0,0 +1,3 @@
|
||||
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
|
||||
<g stroke-linejoin="round"><path d="M14 4C14 2.89543 13.1046 2 12 2H4C2.89543 2 2 2.89543 2 4V12C2 13.1046 2.89543 14 4 14H12C13.1046 14 14 13.1046 14 12V4Z" fill="#4A90F5"/><path transform="translate(5 3.5)" d="M5.5 1.6C5.1 0.9 4.3 0.5 3.4 0.5H2.6C1.4 0.5 0.5 1.3 0.5 2.4C0.5 3.5 1.3 3.9 2.5 4.2L3.5 4.4C4.7 4.7 5.5 5.1 5.5 6.3C5.5 7.5 4.6 8.5 3.4 8.5H2.6C1.6 8.5 0.9 8 0.5 7.4" stroke="#2B2D30"/></g>
|
||||
</svg>
|
||||
|
Після Ширина: | Висота: | Розмір: 506 B |
Reference in new issue
Заблокувати користувача