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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 891432c2d9 fix(diff): run editor text actions on the diff's focused side
Text actions that need only the view (Comment Line, Duplicate Line, Move
Line, Join Lines, Toggle Case, Add Selection for Next Occurrence, Clone Caret
and the like) now also run while a diff or merge editor has focus: editing ones
on its editable side, caret and selection ones on either side. Before, they
were enabled only by editorTextFocus, which the diff never sets, so their keys
did nothing or fell through as typed text. Diff panes now allow several
selections and keep the occurrence search state (search again from the top),
and ⌘D duplicates the line there instead of opening Show Diff.

Closes #4343
2026-11-19 01:16:05 +08:00
Mr0Bread 160ecf4693 fix(index): find files inside git-ignored folders (#4034)
Files inside git-ignored folders are listed in the file index by name only, so Go to File and Search Everywhere find them in the default scope; their contents are not read or parsed. Project-model exclusions, files.exclude, VCS metadata and symlink boundaries stay pruned. Incremental watcher updates follow the same rule (including new ignored subtrees and the polling/per-directory backends), and a stamp bump invalidates old directory snapshots so existing caches pick up the folders they left out.

Measured cold index on macOS: this repository 1.53s / 6,432 files before vs 1.55s / 6,440 after (its large ignored folders are detected exclusions); a synthetic project with 2,000 sources and a git-ignored folder of 50,000 files 0.2s / 2,001 files before vs 0.68s / 52,001 after.

Closes #3972

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 01:05:09 +08:00
Bert Verhelstтаbertyhell cb087fff48 feat(plugins): console highlight rules for Run/Debug output (API 1.12) (#4164)
Plugin API 1.12 adds workspace set-console-rules: a plugin replaces its list of highlight rules (regex in the Rust/JS common subset, validated on the host and bounded to 512 bytes and 100 rules; palette foreground/background, styles, whole-line or match-only, enabled). Every window applies the rules to the stdout and stderr lines of its Run and Debug consoles; the plugin never sees the output, and the rules go away when the plugin stops. Components rebuilt for 1.12.

Closes #3304

Co-authored-by: bertyhell <[email protected]>
2026-11-19 00:34:55 +08:00
GuoYuтаguoyucode 70e0215f46 feat(mcp): paths on every query tool, includeExcluded for the searches (#4299)
The query tools narrow their results one way: `paths` (project-relative globs, `!` excludes, absolute for a project attached outside the project) replaces `scope` on find_references, get_call_hierarchy, get_project_problems, git_status, get_all_open_file_paths, get_run_configurations and list_runs. `paths` only narrows: git-ignored and project-excluded content stays out unless `includeExcluded` is set, which search_text and search_regex now accept too (SearchQuery::include_excluded turns the ignore rules off for that search). search_file walks only the folders the globs lie in instead of the whole project, and list_directory_tree marks git-ignored and IDE-excluded entries once, at the top. An old client's `scope` is ignored and gets whole-project results.

Co-authored-by: guoyucode <[email protected]>
2026-11-19 00:20:38 +08:00
Mansur Akhmadiтаmansur-akhmadi 460d30030e feat(vcs): Show Diff in the annotate gutter's context menu (#4355)
The annotate gutter's context menu gains Show Diff after Show Commit in Git Log. It opens what the line's commit changed in the file against the commit's first parent: an added file shows (does not exist) on the left, a renamed one its old path, and a file renamed later is diffed under its name at that commit (from its --follow history; a merge the history doesn't list is read directly).

Closes #4354

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 00:16:57 +08:00
dervarex edf9affa8e feat(appearance): Smooth scrolling setting for Linux web views (#4330)
Adds Appearance | Smooth scrolling (shown on Linux only). It toggles WebKitGTK's enable-smooth-scrolling on every web view: applied when a web view is created and when the setting changes. It stays on by default; turning it off removes the stutter some Linux setups see when scrolling with the mouse wheel.

Co-authored-by: dervarex <[email protected]>
2026-11-19 00:13:31 +08:00
Vladislav Kuzmin 070c795de5 fix(database): preserve the ClickHouse account default and explain reconnects (#4346)
A source without a configured database no longer sends database=default on its HTTP requests, so stateless requests honour the account's own default database. A lost HTTP session (code 372) now tells the user to reconnect and explains that both expiry and load-balancer routing cause it.

Co-authored-by: principalwater <[email protected]>
2026-11-19 00:10:46 +08:00
l0ng-ai 5c9290fefd feat(deployment): use a server group as the default deployment target (#4357)
A server group can be marked as the default deployment target. Upload to <group> uploads to each of its servers in turn; automatic upload and remote deletes on save reach every server of the default group, with their results merged into one report.

Closes #4322
2026-11-19 00:09:06 +08:00
l0ng-ai 0527ff4218 feat(project-view): show user scopes as Project view panes (#4356)
Scopes defined in Settings > Scopes were only used by File Colors and Find in Files. The Project view's pane switcher now lists them after the built-in panes. Choosing one shows only that scope's files under their folders, like Open Files and All Changed Files. The pane updates as files are created or removed and as the scopes change. The new scope_files command lists a scope's files, at most 20000.

Closes #4315
2026-11-19 00:01:47 +08:00
l0ng-ai e5b2f4dfc7 feat(toolwindows): remember size for each tool window (#4353)
Tool windows on one side shared a single size, so switching from a resized Terminal to Debug and back lost the Terminal's height. The new Appearance option "Remember size for each tool window" (off by default) keeps each window's last size along its side and restores it when the window shows again. The size comes from dragging or from the Resize Tool Window actions. It is saved with the project layout and in saved tool window layouts.

Closes #4326
2026-11-18 23:53:47 +08:00
l0ng-ai a3617aa3e9 fix(structure): keep File Structure from jumping on unmatched queries (#4329)
With Narrow down on typing off, a query that matched nothing selected the first symbol, and Enter jumped to it. The popup now clears the selection when nothing matches and shows No matches next to the field, so Enter leaves the caret where it is. Adds Tree.clearSelection.

Closes #4212
2026-11-18 23:51:40 +08:00
l0ng-ai bd7d4c475b fix(keymap): record double-modifier shortcuts (#4328)
The shortcut recorder (Find Actions by Shortcut and Add Keyboard Shortcut) only saw single keystrokes, so it ignored double-modifier gestures such as Shift, Shift or Ctrl, Ctrl that the dispatcher supports. Double-modifier recognition moves out of the dispatcher into a recognizer that the recorder now shares. A double tap records the gesture. Holding the second tap with a key records Modifier Modifier+Key. Focus loss, a mouse press or a trackpad swipe resets it.

Closes #4225
2026-11-18 23:51:33 +08:00
l0ng-ai 15e32d5af6 feat(vcs): edit Directory Mappings to exclude or add Git repositories (#4351)
Directory Mappings listed only the project root, read-only. It now lists the detected repositories and those added by hand. Setting a repository to <none> removes it from the Git and Commit tool windows and from IDE-wide Git operations, while its files stay in the project. + adds a repository root that detection does not reach, and - removes an added one. The mappings are saved per project (vcs.mappings) and apply on every rescan. Adds Repos::mapped and the vcs_detected_roots command.

Closes #4157
2026-11-18 23:43:10 +08:00
l0ng-ai 3de76f1a63 fix(search): Find Action hides actions that cannot run (#4327)
Find Action only checked an action's when clause, not its enabled() check, so Annotate with Git Blame on an untracked file, Show Current Revision, or Set NULL with no data grid focused were listed as enabled and did nothing. Matching now uses isActionEnabled, the same check menus and shortcuts use. When Include disabled actions is unchecked, unavailable actions are hidden, also from the recent list. The database cell actions are enabled only while a grid has focus (a popup opened from the grid keeps the grid it captured). An empty Actions tab says Nothing found.

Closes #4223
2026-11-18 23:41:40 +08:00
l0ng-ai 262b91d89a fix(bookmarks): keep bookmarks when files and folders are renamed (#4325)
A rename in the Project view reached the bookmark store as a removal: the watcher's fsChanged event dropped the bookmarks of the old path before the rename's own mapping arrived. Bookmarks now follow explicit moves through onFilesMoved. A watcher removal waits for any move in progress in the same project, and drops a bookmark only when its path is really gone (an Undo or rollback may already have restored it).

Closes #4210
2026-11-18 23:38:57 +08:00
l0ng-ai 4d6a21c695 fix(terminal): keep the active ConPTY prompt when a terminal resizes (#4324)
When a ConPTY terminal got narrower (for example, a split opened and then closed), xterm dropped the end of the active PowerShell prompt. PowerShell then echoed input at absolute columns without printing the prompt again, so it came back garbled. Local terminals and embedded Run consoles now turn on xterm's cursor-line reflow on Windows builds whose ConPTY needs it. Remote and non-Windows sessions are unchanged.

Closes #4155
2026-11-18 23:32:50 +08:00
l0ng-ai 7de8fb850e fix(bookmarks): keep bookmarks on surviving lines after edits (#4323)
Deleting a bookmarked line next to another bookmark mapped both gutter markers onto the same line and re-matched the stored bookmarks by index. The surviving bookmark lost its mnemonic, description and list. The gutter now carries each bookmark through the edit. A bookmark is dropped only when its own line was removed, and the others keep their metadata, also across Undo and Redo.

Closes #4207
2026-11-18 23:30:45 +08:00
l0ng-ai acb850758a feat(vcs): option to detect changes with the Git command line (#4350)
Encryption or file protection layers can make the file metadata gitoxide reads differ from what the system git sees, so unchanged files showed as modified while git status was clean. The new Git setting "Detect changes with the Git command line" (vcs.git.cliStatus, off by default) reads the full working-tree status with git status, the same reader the partial refresh already used.

Closes #4124
2026-11-18 23:30:30 +08:00
l0ng-ai 6bf69cfb2a feat(java): strike out deprecated classes in the Project view and editor tabs (#4349)
The JVM file presentation now reports whether a file's primary type is deprecated: annotated @Deprecated (Java and Kotlin), or a Java type whose Javadoc has a @deprecated tag. The Project view and editor tabs strike the name out, and an error marker on the same file still shows.

Closes #4151
2026-11-18 23:21:04 +08:00
l0ng-ai 6829022b71 feat(vcs): ask for the Git user name and email before committing without them (#4348)
Committing in a repository without user.name or user.email failed with Git's error. Commit now first opens the Git User Name Is Not Defined dialog. The dialog proposes the identity the other repositories share and validates the name and email. It sets them globally by default, or in each repository that lacks them when the box is unchecked, and then the commit continues. Adds Repo::set_user_identity and the trusted vcs_set_user_identity command.

Closes #4175
2026-11-18 23:14:15 +08:00
l0ng-ai 54611ff80a fix(lsp): launch Windows npm language servers with an overlong PATH (#4314)
cmd.exe drops an inherited PATH over 8,191 UTF-16 code units, so npm launchers such as vtsls.cmd could not find Node. Before a Windows batch launch, missing absolute drive paths are pruned from an overlong PATH when that makes it fit, keeping the order of the rest. Explicit environment variables are now set before process preparation so they take precedence.
2026-11-18 23:05:05 +08:00
l0ng-ai cacfc4142f fix(vfs): reject ambiguous Windows file destinations (#4312)
Windows strips a trailing period or space from a path component, so the project tree and the editor ended up with different names for one file. The name editor now explains the rule, and the VFS rejects such destinations before creating, copying or renaming (verbatim paths excepted).
2026-11-18 23:04:28 +08:00
l0ng-ai 237f7ee5a5 fix(templates): expand live templates across matching carets (#4313)
Live templates expand at every caret sharing the same eligible prefix, in one undo step, keeping the primary caret and linking fields across the expansions. Mixed prefixes or syntax contexts fall back to the normal Tab edit.
2026-11-18 23:03:29 +08:00
l0ng-ai 2321929709 fix(terminal): keep the terminal from sliding sideways while composing (#4347)
A TUI that leaves the cursor in the last column pushed xterm's input textarea and IME composition past the right edge, and Chromium (WebView2) scrolled the clipping pane to keep the caret visible. The xterm element now clips its overflow, so no ancestor can scroll.
2026-11-18 23:02:51 +08:00
l0ng-ai 6d788cb6f8 fix(project-view): restore the contents of the last deletion (#4309)
Project View Undo restores the snapshot taken by that specific Delete, including empty folders and the files' exact bytes (BOM, line endings); earlier deletions stay deleted. Entries that cannot be restored (contents not captured, path now occupied) are named in the warning, which points to the system Trash.
2026-11-18 22:59:48 +08:00
l0ng-ai 662c32eb05 fix(editor): discard gutter color previews on Escape (#4285)
The gutter color picker previews a color without editing the document. Escape or Cancel dismisses the preview; Apply or clicking outside commits the color, and one Undo restores the original.
2026-11-18 22:56:41 +08:00
l0ng-ai 82ff84e69e fix(vcs): activate diff hunk buttons with the keyboard (#4311)
Diff hunk buttons (arrows, hover Revert, unified Revert) apply the change on click, so Enter and Space work as well as the pointer; a pointer press still keeps editor focus. The unified Revert test added since now activates the button with a click.
2026-11-18 22:55:57 +08:00
l0ng-ai 7ec0d3dbec fix(workbench): restore focus before running main-menu actions (#4310)
The custom main menu returns focus to the editor or field that opened it before running an action, so Edit › Undo / Redo reach the editor and workspace history (e.g. after Rename) instead of running while the menu button holds focus.
2026-11-18 22:54:23 +08:00
l0ng-ai 466556603d fix(editor): keep completion open inside an identifier (#4304)
Basic Completion no longer auto-inserts a sole suggestion when the caret is inside an identifier; the lookup stays open so Tab replaces the whole identifier (including a Unicode suffix). A sole suggestion at the end of a prefix still inserts at once.
2026-11-18 22:54:05 +08:00
l0ng-ai 3b2deb6ad8 fix(java): keep a Maven build's processor output away from jdtls (#4344)
jdtls runs annotation processors itself and writes to the same generated-sources/annotations folder as javac. A Maven build's rewrite of those files reached jdtls as a watched-file change; jdtls compiled javac's copy, failed to resolve the mapper and overwrote target/classes with an 'Unresolved compilation problems' class. Changes under generated-sources/annotations and generated-test-sources/test-annotations are no longer sent to jdtls.
2026-11-18 22:53:28 +08:00
l0ng-ai f2429a8c14 docs: suggest XWayland first for a Linux window that stops responding (#4342)
XWayland keeps the GPU renderer and stayed responsive on the setup in #4244, so the troubleshooting entry suggests GDK_BACKEND=x11 before turning the DMA-BUF renderer off.
2026-11-18 22:44:01 +08:00
l0ng-ai f3e80ba020 feat(http-client): navigate from a request URL to its endpoint handler (#4341)
⌘-click / Go to Declaration on a request URL in a .http file opens the handler of the endpoint it reaches, matched by method and path ({var}/*/** in the mapping, {{var}} in the request, an optional context path).
2026-11-18 22:42:02 +08:00
359 змінених файлів з 7045 додано та 1558 видалено

No files matched your search

Створено
+1
Переглянути файл
@@ -6734,6 +6734,7 @@ dependencies = [
"tracing",
"tracing-appender",
"tracing-subscriber",
"webkit2gtk",
"webview2-com",
"windows",
"windows-sys 0.61.2",
+79 -4
Переглянути файл
@@ -16,18 +16,55 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
/// For a `tokio::process::Command`, pass `cmd.as_std_mut()`.
///
/// - Windows: release builds use the GUI subsystem, so without `CREATE_NO_WINDOW` every
/// console child flashes a `cmd` window.
/// console child flashes a `cmd` window. Batch files also need a PATH small enough for cmd.
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
///
/// Variables the call site has already set are kept; call it before `env_clear` and after
/// `current_dir`, which picks the project environment.
/// Explicit variables take precedence over the host environment. Call after setting
/// `current_dir` and any explicit `PATH`, and before `env_clear`.
pub fn prepare(cmd: &mut Command) -> &mut Command {
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
cmd.creation_flags(CREATE_NO_WINDOW);
}
host_env(cmd)
host_env(cmd);
#[cfg(windows)]
compact_batch_path(cmd);
cmd
}
#[cfg(windows)]
fn compact_batch_path(cmd: &mut Command) {
use std::os::windows::ffi::OsStrExt;
use std::path::{Component, Prefix};
// Rust runs these files through cmd.exe, which drops inherited variables over this limit.
const CMD_ENV_LIMIT: usize = 8191;
let extension = Path::new(cmd.get_program()).extension();
if !extension.is_some_and(|ext| ext.eq_ignore_ascii_case("cmd") || ext.eq_ignore_ascii_case("bat")) {
return;
}
let path = match cmd.get_envs().find(|(key, _)| key.eq_ignore_ascii_case("PATH")) {
Some((_, path)) => path.map(OsStr::to_owned),
None => std::env::var_os("PATH"),
};
let Some(path) = path.filter(|p| p.encode_wide().count() > CMD_ENV_LIMIT) else { return };
// The IDE includes possible locations of as-yet uninstalled tools. Prune paths that are
// missing now, keeping search precedence and leaving UNC and relative paths alone.
let dirs = std::env::split_paths(&path).filter(|dir| {
let local = dir.is_absolute()
&& matches!(dir.components().next(), Some(Component::Prefix(p))
if matches!(p.kind(), Prefix::Disk(_) | Prefix::VerbatimDisk(_)));
!local
|| !std::fs::symlink_metadata(dir)
.is_err_and(|e| matches!(e.kind(), std::io::ErrorKind::NotFound | std::io::ErrorKind::NotADirectory))
});
if let Ok(compact) = std::env::join_paths(dirs)
&& compact.encode_wide().count() <= CMD_ENV_LIMIT
{
cmd.env("PATH", compact);
}
}
/// Starts the child as the leader of its own process group on Unix, so [`kill_tree`] and
@@ -885,6 +922,44 @@ mod tests {
assert!(!process_alive(pid));
}
#[cfg(windows)]
#[test]
fn batch_launch_keeps_runtime_paths_when_cmd_would_drop_path() {
let root = tempfile::tempdir().unwrap();
let script = root.path().join("server.CMD");
std::fs::write(&script, "@echo off\r\nif not defined PATH exit /b 42\r\n").unwrap();
let selected = root.path().join("Selected Runtime");
let fallback = root.path().join("Fallback Runtime");
std::fs::create_dir(&selected).unwrap();
std::fs::create_dir(&fallback).unwrap();
let relative = Path::new("relative");
let unc = Path::new(r"\\openidea-test\share\bin");
let missing = root.path().join("uninstalled-".repeat(12));
let path = std::env::join_paths(
std::iter::once(selected.as_path()).chain(std::iter::repeat_n(missing.as_path(), 60)).chain([
unc,
relative,
fallback.as_path(),
]),
)
.unwrap();
let compact = std::env::join_paths([selected.as_path(), unc, relative, fallback.as_path()]).unwrap();
let path_in = |cmd: &Command| {
cmd.get_envs()
.find_map(|(key, value)| key.eq_ignore_ascii_case("PATH").then(|| value.map(OsStr::to_owned)))
.flatten()
};
let mut cmd = Command::new(&script);
cmd.current_dir(root.path()).env("PATH", &path);
prepare(&mut cmd);
assert_eq!(path_in(&cmd), Some(compact));
assert!(cmd.status().unwrap().success());
let mut native = Command::new(root.path().join("server.exe"));
assert_eq!(path_in(prepare(native.env("PATH", &path))), Some(path));
}
#[cfg(unix)]
#[test]
fn process_alive_rejects_ids_that_are_not_a_single_process() {
+16
Переглянути файл
@@ -752,6 +752,8 @@ pub struct AppearanceSettings {
pub compact_mode: bool,
/// IDEA "Use smaller indents in trees": tool window trees indent less per level.
pub small_tree_indents: bool,
/// Linux: WebKit animates each mouse wheel step
pub smooth_scrolling: bool,
pub full_path_in_title: bool,
pub project_colors_in_toolbar: bool,
pub dnd_with_alt_only: bool,
@@ -770,6 +772,8 @@ pub struct AppearanceSettings {
pub show_tool_window_names: bool,
pub show_tool_window_badges: bool,
pub widescreen_tool_windows: bool,
/// Each tool window keeps its own size; off, the windows of a side share one.
pub remember_tool_window_sizes: bool,
/// View › Appearance › Toolbar; hidden leaves IDEA's compact window header.
pub show_main_toolbar: bool,
pub show_status_bar: bool,
@@ -885,6 +889,7 @@ impl Default for AppearanceSettings {
different_tool_window_background: false,
compact_mode: false,
small_tree_indents: false,
smooth_scrolling: true,
full_path_in_title: false,
project_colors_in_toolbar: true,
dnd_with_alt_only: false,
@@ -898,6 +903,7 @@ impl Default for AppearanceSettings {
show_tool_window_names: false,
show_tool_window_badges: true,
widescreen_tool_windows: false,
remember_tool_window_sizes: false,
show_main_toolbar: true,
show_status_bar: true,
navigation_bar: NavigationBarPosition::StatusBar,
@@ -1752,6 +1758,16 @@ mod tests {
assert_eq!(kept.appearance.theme, "solarized-dark");
}
#[test]
fn smooth_scrolling_defaults_on_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"appearance":{"zoom":110}}"#).unwrap();
assert!(old.appearance.smooth_scrolling);
let off: Settings = serde_json::from_str(r#"{"appearance":{"smoothScrolling":false}}"#).unwrap();
assert!(!off.appearance.smooth_scrolling);
let json = serde_json::to_value(&off).unwrap();
assert_eq!(json["appearance"]["smoothScrolling"], false);
}
#[test]
fn window_close_settings_default_off_and_round_trip() {
for old in [r#"{}"#, r#"{"general":{"confirmExit":false}}"#] {
+33
Переглянути файл
@@ -20,6 +20,34 @@ pub struct VcsSettings {
pub shelf: ShelfSettings,
/// Issue Navigation: commit-message patterns turned into links.
pub issue_navigation: Vec<IssueLink>,
/// Directory Mappings: repository roots added to or excluded from the detected ones.
pub mappings: VcsMappings,
}
/// Directory Mappings on top of repository detection. Paths are relative to the project
/// root (`.` for the root itself) or absolute outside it.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct VcsMappings {
/// Detected repositories the IDE leaves alone: no Git or Commit integration, files stay.
pub excluded: Vec<String>,
/// Repository roots detection does not reach (outside the project, or deeper).
pub added: Vec<String>,
}
impl VcsMappings {
pub fn is_empty(&self) -> bool {
self.excluded.is_empty() && self.added.is_empty()
}
/// `path` resolved against `project_root`.
pub fn resolve(project_root: &std::path::Path, path: &str) -> std::path::PathBuf {
match path {
"" | "." => project_root.to_path_buf(),
p if std::path::Path::new(p).is_absolute() => p.into(),
p => project_root.join(p),
}
}
}
impl Default for VcsSettings {
@@ -34,6 +62,7 @@ impl Default for VcsSettings {
confirmation: VcsConfirmationSettings::default(),
shelf: ShelfSettings::default(),
issue_navigation: Vec::new(),
mappings: VcsMappings::default(),
}
}
}
@@ -77,6 +106,9 @@ pub struct GitSettings {
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
/// stage and unstage instead of inclusion checkboxes, and no change lists.
pub staging_area: bool,
/// Scan the working tree with `git status` (for file systems whose metadata only
/// the system git reads correctly) instead of in process.
pub cli_status: bool,
}
impl Default for GitSettings {
@@ -101,6 +133,7 @@ impl Default for GitSettings {
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
cli_status: false,
}
}
}
+17 -3
Переглянути файл
@@ -32,7 +32,7 @@ struct Session {
/// The response format: a names line, a types line, then one JSON array per row, so rows past
/// the grid's limit are skipped without being parsed.
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
const SESSION_LOST: &str = "ClickHouse HTTP session not found on this node (code 372). Use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
const SESSION_LOST: &str = "ClickHouse HTTP session expired or is missing on this node (code 372). Reconnect to start a new session. Behind a load balancer, use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
pub(crate) fn transaction_error() -> IdeError {
IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
@@ -133,7 +133,7 @@ impl ClickhousePool {
endpoint,
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
password: password.unwrap_or_default().to_owned(),
database: if database.is_empty() { "default".into() } else { database.into() },
database: database.into(),
settings,
read_only: source.read_only,
session: Mutex::new(Session {
@@ -233,7 +233,7 @@ impl ClickhousePool {
request = request.query(&[("session_check", "1")]);
}
}
if session.id.is_none() || !session.initialized {
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only && !session.strict_read_only {
@@ -808,6 +808,19 @@ mod tests {
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
}
#[tokio::test]
async fn an_unset_database_uses_the_accounts_default_in_both_modes() {
for mode in ["true", "false"] {
let (port, requests) = server(vec![("200 OK", "", ONE); 2]).await;
let source = DataSource { properties: vec![property("use_http_session", mode)], ..source(port) };
let pool = Pool::connect(&source, None, None).await.unwrap();
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
for request in requests.await.unwrap() {
assert_eq!(query_value(&request_url(&request), "database"), None);
}
}
}
#[tokio::test]
async fn stateless_requests_keep_database_settings_readonly_and_limits() {
let (port, requests) = server(vec![("200 OK", "", ONE); 3]).await;
@@ -855,6 +868,7 @@ mod tests {
let error = pool.execute(sql, 0, &CancellationToken::new()).await.unwrap_err();
assert!(error.message.contains("372"));
assert!(error.message.contains("one node or session affinity"));
assert!(error.message.contains("Reconnect"));
assert!(error.message.contains("use_http_session=false"));
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
+1 -1
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.11.0";
pub const ENGINE_VERSION: &str = "1.12.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
+1
Переглянути файл
@@ -869,6 +869,7 @@ async fn occurrences(
scope,
max_matches: 0,
context,
include_excluded: false,
};
let host = call.host();
let request = crate::mcp::tool::request_id();
+8 -8
Переглянути файл
@@ -1,5 +1,5 @@
use super::page::{OFFSET, Page};
use super::scope::{self, Scope};
use super::search::{PathScope, paths_param};
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{Diagnostic, IdeResult, Severity};
use serde_json::{Map, Value, json};
@@ -16,7 +16,7 @@ pub fn tools() -> Vec<Tool> {
Use this tool to explore current open editors.",
open_editors,
)
.param(scope::param()),
.param(paths_param()),
Tool::new(
"get_current_file",
"Returns the focused editor's file and selection reported by the IDE.
@@ -45,20 +45,20 @@ Lines and UTF-16 columns are 1-based.",
project_problems,
)
.param(Param::optional("errorsOnly", ParamType::Boolean, "Only errors (default) or warnings too"))
.param(scope::param())
.param(paths_param())
.param(Param::optional("limit", ParamType::Integer, "Problems to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET)),
]
}
async fn open_editors(call: Call) -> IdeResult<Output> {
let dir = Scope::of(&call)?;
let paths = PathScope::of(&call)?;
let windows = call.host.mcp_windows(call.root());
let open = call.host.mcp_reports.editors(&windows);
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
let active = call.host.mcp_reports.focused(call.window()).filter(|e| paths.matches_path(&e.path.0));
Output::json(json!({
"activeFilePath": active.map(|e| call.display(&e.path.0)),
"openFiles": open.iter().filter(|p| dir.contains(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
"openFiles": open.iter().filter(|p| paths.matches_path(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
}))
}
@@ -103,11 +103,11 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
async fn project_problems(call: Call) -> IdeResult<Output> {
let page = Page::of(&call, PROBLEMS_LIMIT)?;
let errors_only = call.flag("errorsOnly", true)?;
let dir = Scope::of(&call)?;
let paths = PathScope::of(&call)?;
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
let problems: Vec<(String, Value)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.filter(|f| paths.matches_path(&f.path.0))
.flat_map(|f| {
let path = call.display(&f.path.0);
let wanted = f.items.into_iter().filter(|d| !errors_only || d.severity == Severity::Error);
+124 -14
Переглянути файл
@@ -8,9 +8,10 @@ use crate::mcp::util::{
self, RELATIVE_PATH_IN_PROJECT_DESCRIPTION, TIMED_OUT_DESCRIPTION, TIMEOUT_MILLISECONDS_DESCRIPTION,
};
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_search::FileMask;
use serde::Serialize;
use serde_json::json;
use std::path::Path;
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
const DEFAULT_READ_LIMIT: i64 = 2000;
@@ -166,7 +167,9 @@ fn list_directory_tree() -> Tool {
"Provides a tree representation of the specified directory in the pseudo graphic format like `tree` utility does.
Use this tool to explore the contents of a directory or the whole project.
You MUST prefer this tool over listing directories via command line utilities like `ls` or `dir`.
A page that starts inside a directory repeats the lines of the directories above it.",
A page that starts inside a directory repeats the lines of the directories above it.
What `.gitignore` ignores is marked [git-ignored] and what the project excludes [ide-excluded]; entries inside a
marked directory are not marked again.",
|call| async move {
let directory = call.str("directoryPath")?;
let max_depth = call.opt_i64("maxDepth")?.unwrap_or(DEFAULT_TREE_DEPTH);
@@ -181,6 +184,12 @@ A page that starts inside a directory repeats the lines of the directories above
}
let deadline = Instant::now() + Duration::from_millis(timeout.max(0) as u64);
let cancel = call.cancel.clone();
let marks = Marks {
root: call.root().to_path_buf(),
excludes: FileMask::new(&[], &call.project().search_excludes()).ok(),
};
// The directory itself, when it or one above it is left out.
let root_mark = marker(ide_index::walk_skips(call.root(), &dir), marks.ide_excluded(&dir, true));
let mut tree = TreeRender {
out: String::new(),
errors: Vec::new(),
@@ -190,11 +199,12 @@ A page that starts inside a directory repeats the lines of the directories above
page,
seen: 0,
above: Vec::new(),
marks,
};
let tree = call
.host()
.blocking(move || {
tree.render(&dir, "", true, max_depth, true);
tree.render(&dir, "", true, max_depth, true, root_mark, !root_mark.is_empty());
Ok(tree)
})
.await?;
@@ -234,7 +244,8 @@ A page that starts inside a directory repeats the lines of the directories above
/// The `tree`-like listing: the directory's absolute path, then every entry (hidden and
/// ignored ones too) by lower-cased name, directories marked with `/`; entries outside the
/// page are counted, not listed.
/// page are counted, not listed. An entry left out of the project is marked, the entries
/// inside it are not.
struct TreeRender {
out: String,
errors: Vec<String>,
@@ -246,10 +257,48 @@ struct TreeRender {
seen: usize,
/// The lines of the directories above the entry, and whether this page shows them yet.
above: Vec<(String, bool)>,
marks: Marks,
}
/// What the project leaves out, to mark in the listing.
struct Marks {
root: PathBuf,
/// The project's exclusions (excluded folders, "Exclude files" names), as Find in Files applies them.
excludes: Option<FileMask>,
}
impl Marks {
fn ide_excluded(&self, path: &Path, is_dir: bool) -> bool {
let (Some(mask), Ok(rel)) = (&self.excludes, path.strip_prefix(&self.root)) else { return false };
let rel = rel.to_string_lossy().replace('\\', "/");
// A directory is excluded with the files in it.
!rel.is_empty() && !mask.matches(&if is_dir { format!("{rel}/x") } else { rel })
}
}
/// Spelled out, so that the listing says what it means.
fn marker(git_ignored: bool, ide_excluded: bool) -> &'static str {
match (git_ignored, ide_excluded) {
(true, true) => " [git-ignored] [ide-excluded]",
(true, false) => " [git-ignored]",
(false, true) => " [ide-excluded]",
(false, false) => "",
}
}
impl TreeRender {
fn render(&mut self, path: &Path, indent: &str, is_last: bool, max_depth: i64, is_root: bool) {
/// `mark`: the entry's marker; `marked`: it or a directory above it is marked.
#[allow(clippy::too_many_arguments)]
fn render(
&mut self,
path: &Path,
indent: &str,
is_last: bool,
max_depth: i64,
is_root: bool,
mark: &str,
marked: bool,
) {
if max_depth <= 0 || self.timed_out || self.cancel.is_cancelled() {
return;
}
@@ -268,7 +317,7 @@ impl TreeRender {
path.file_name().unwrap_or_default().to_string_lossy().into_owned()
};
let is_dir = path.is_dir() && !path.is_symlink();
let line = format!("{indent}{prefix}{name}{}\n", if is_dir { "/" } else { "" });
let line = format!("{indent}{prefix}{name}{}{mark}\n", if is_dir { "/" } else { "" });
let shown = if is_root {
self.out.push_str(&line);
true
@@ -278,22 +327,38 @@ impl TreeRender {
if !is_dir {
return;
}
let mut children: Vec<_> = match std::fs::read_dir(path) {
Ok(entries) => entries.filter_map(|e| e.ok().map(|e| e.path())).collect(),
// Without exclusions, `ignored` is what `.gitignore` says.
let mut children: Vec<(PathBuf, bool)> = match ide_vfs::read_dir(path, &[]) {
Ok(entries) => entries.into_iter().map(|e| (e.path.0, e.ignored)).collect(),
Err(e) => {
self.errors.push(format!("Failed to read {}: {e}", path.display()));
self.errors.push(format!("Failed to read {}: {}", path.display(), e.message));
return;
}
};
let key = |p: &std::path::PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
children.sort_by_cached_key(|p| (key(p).to_lowercase(), key(p)));
let key = |p: &PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
children.sort_by_cached_key(|(p, _)| (key(p).to_lowercase(), key(p)));
let child_indent = format!("{indent}{}", if is_last { " " } else { "│ " });
let n = children.len();
if !is_root {
self.above.push((line, shown));
}
for (i, child) in children.iter().enumerate() {
self.render(child, &child_indent, i + 1 == n, max_depth - 1, false);
// Inside a marked directory nothing is marked again.
for (i, (child, git_ignored)) in children.iter().enumerate() {
let child_mark = if marked {
""
} else {
let child_dir = child.is_dir() && !child.is_symlink();
marker(*git_ignored, self.marks.ide_excluded(child, child_dir))
};
self.render(
child,
&child_indent,
i + 1 == n,
max_depth - 1,
false,
child_mark,
marked || !child_mark.is_empty(),
);
}
if !is_root {
self.above.pop();
@@ -383,8 +448,9 @@ mod tests {
page: Page { offset, limit },
seen: 0,
above: Vec::new(),
marks: Marks { root: tmp.path().to_path_buf(), excludes: None },
};
tree.render(tmp.path(), "", true, 5, true);
tree.render(tmp.path(), "", true, 5, true, "", false);
let root = format!("{}/\n", tmp.path().display());
(tree.out.strip_prefix(&root).unwrap().to_owned(), tree.seen)
};
@@ -396,4 +462,48 @@ mod tests {
);
assert_eq!(render(0, 100).0, " ├── a/\n │ ├── x.txt\n │ └── y.txt\n └── b.txt\n");
}
#[test]
fn what_the_project_leaves_out_is_marked_once() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap();
for file in ["ign/deep/a.txt", "out/b.txt", "both/c.txt", "src/d.txt", "src/e.log"] {
let path = root.join(file);
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, "").unwrap();
}
std::fs::write(root.join(".gitignore"), "ign/\nboth/\n*.log\n").unwrap();
let excludes = ["out/**".to_owned(), "both/**".to_owned()];
let mut tree = TreeRender {
out: String::new(),
errors: Vec::new(),
timed_out: false,
deadline: Instant::now() + Duration::from_secs(10),
cancel: CancellationToken::new(),
page: Page { offset: 0, limit: 100 },
seen: 0,
above: Vec::new(),
marks: Marks { root: root.clone(), excludes: FileMask::new(&[], &excludes).ok() },
};
tree.render(&root, "", true, 5, true, "", false);
let listing = tree.out.strip_prefix(&format!("{}/\n", root.display())).unwrap().to_owned();
assert_eq!(
listing,
[
" ├── .gitignore",
" ├── both/ [git-ignored] [ide-excluded]",
" │ └── c.txt",
" ├── ign/ [git-ignored]",
" │ └── deep/",
" │ └── a.txt",
" ├── out/ [ide-excluded]",
" │ └── b.txt",
" └── src/",
" ├── d.txt",
" └── e.log [git-ignored]",
"",
]
.join("\n")
);
}
}
-1
Переглянути файл
@@ -10,7 +10,6 @@ mod files;
mod http;
mod page;
pub mod reports;
mod scope;
mod search;
mod symbols;
mod tool;
+3 -3
Переглянути файл
@@ -305,7 +305,7 @@ pub fn list_runs() -> Tool {
start of the command, exit code and times. `get_run_status` gives a tab's whole status.",
|call| async move {
let page = Page::of(&call, LIST_LIMIT)?;
let dir = crate::mcp::scope::Scope::of(&call)?;
let paths = crate::mcp::search::PathScope::of(&call)?;
let wanted = call.opt_str("state")?.filter(|s| s != "all");
let states = match wanted.as_deref() {
None => None,
@@ -327,7 +327,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
.rev()
.map(|r| r.status())
// A tab belongs where its command runs.
.filter(|s| dir.contains_shown(call.root(), s["workingDirectory"].as_str().unwrap_or_default()))
.filter(|s| paths.matches_dir(&call.root().join(s["workingDirectory"].as_str().unwrap_or_default())))
.filter(|s| {
states.as_ref().is_none_or(|states| s["state"].as_str().is_some_and(|v| states.contains(&v)))
})
@@ -344,7 +344,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
ParamType::String,
"all (default), running, idle (not running), error (failed, crashed, startFailed), or one state",
))
.param(crate::mcp::scope::param())
.param(crate::mcp::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+5 -3
Переглянути файл
@@ -139,12 +139,14 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
}
let page = Page::of(&call, CONFIGURATIONS_LIMIT)?;
let query = call.opt_str("query")?.map(|q| q.to_lowercase());
let dir = crate::mcp::scope::Scope::of(&call)?;
let paths = crate::mcp::search::PathScope::of(&call)?;
let list: Vec<Value> = configs
.iter()
// A configuration belongs where it runs.
.filter(|c| {
dir.contains(&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)))
paths.matches_dir(
&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)),
)
})
.filter(|c| {
query.as_ref().is_none_or(|q| {
@@ -169,7 +171,7 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
in the file instead of project-wide run configurations.",
))
.param(Param::optional("query", ParamType::String, "Only configurations whose name, type or command contains it"))
.param(crate::mcp::scope::param())
.param(crate::mcp::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
-56
Переглянути файл
@@ -1,56 +0,0 @@
//! The `scope` argument of the query tools: the directory their results are limited to, a
//! folder of the project or a project attached to it.
use crate::mcp::tool::{Call, Param, ParamType};
use ide_core::{IdeError, IdeResult};
use std::path::{Path, PathBuf};
pub fn param() -> Param {
Param::optional(
"scope",
ParamType::String,
"Directory to limit results to: relative to the project root, or absolute",
)
}
/// No `scope`: everything.
pub struct Scope(Option<PathBuf>);
impl Scope {
pub fn of(call: &Call) -> IdeResult<Self> {
let Some(raw) = call.opt_str("scope")?.filter(|s| !s.trim().is_empty()) else { return Ok(Self(None)) };
let given = Path::new(raw.trim());
let path = crate::mcp::tool::normalize(&if given.is_absolute() {
given.to_path_buf()
} else {
call.root().join(given)
});
let roots: Vec<PathBuf> =
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
if !ide_vfs::content_path_allowed(&path, &roots) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
let path = dunce::canonicalize(&path).unwrap_or(path);
if !path.is_dir() {
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
}
if !roots.iter().any(|root| path.starts_with(root)) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
Ok(Self(Some(path)))
}
pub fn dir(&self) -> Option<&Path> {
self.0.as_deref()
}
pub fn contains(&self, path: &Path) -> bool {
self.0.as_ref().is_none_or(|dir| path.starts_with(dir))
}
/// For a path the tools return: project-relative with `/`, or absolute.
pub fn contains_shown(&self, root: &Path, path: &str) -> bool {
self.0.is_none() || self.contains(&root.join(path))
}
}
+173 -65
Переглянути файл
@@ -6,7 +6,6 @@
//! the editor (one per character except emoji and other astral characters).
use crate::mcp::page::{OFFSET, Page};
use crate::mcp::scope::{self, Scope};
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use crate::mcp::util::{INDEXING_PARTIAL_RESULT_REASON, MEDIUM_TIMEOUT};
use crate::ops::search::SearchEvent;
@@ -37,8 +36,10 @@ const MIN_UNMASKED_MATCHES: usize = 10_000;
/// outside the window of a longer line are left out.
const LINE_WINDOW: usize = 500;
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results. Supports '!' \
excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as '**/pattern'. Empty strings are ignored.";
const INCLUDE_EXCLUDED_DESCRIPTION: &str = "Whether to include excluded/ignored files in results";
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results (absolute ones for a \
project attached outside it). Supports '!' excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as \
'**/pattern'. Empty strings are ignored.";
const LIMIT_DESCRIPTION: &str = "Results to return at most (default 100)";
const SYMBOL_LIMIT_DESCRIPTION: &str = "Results to return at most (default 50)";
const CONTEXT_DESCRIPTION: &str = "Lines around each match to return besides the matched line (`lineText`): \"+N\" the \
@@ -68,8 +69,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, false).await },
)
.param(Param::required("q", ParamType::String, "Text to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
@@ -91,8 +92,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|call| async move { text_search(call, true).await },
)
.param(Param::required("q", ParamType::String, "Regex pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
@@ -113,8 +114,7 @@ If you don't find a suitable result, try again with include_external=true to sea
|call| async move { symbol_search(call).await },
)
.param(Param::required("q", ParamType::String, "Symbol query text"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(paths_param())
.param(Param::optional(
"include_external",
ParamType::Boolean,
@@ -140,13 +140,8 @@ Paths are optional additional glob filters relative to the project root.",
|call| async move { file_search(call).await },
)
.param(Param::required("q", ParamType::String, "Glob pattern to search for"))
.param(scope::param())
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
.param(Param::optional(
"includeExcluded",
ParamType::Boolean,
"Whether to include excluded/ignored files in results",
))
.param(paths_param())
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
.output(result_schema())
@@ -336,22 +331,39 @@ async fn fill_lines(
// --- path globs ----------------------------------------------------------------
/// The `paths` argument: project-relative globs, `!` excludes.
struct PathScope {
/// The `paths` argument every query tool takes.
pub(crate) fn paths_param() -> Param {
Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION)
}
/// The `paths` argument: project-relative globs (absolute ones in a project attached outside
/// the project), `!` excludes. It only narrows: what the project leaves out stays out.
#[derive(Clone)]
pub(crate) struct PathScope {
root: PathBuf,
/// `None` when only excludes were given (everything is included).
include: Option<GlobSet>,
exclude: GlobSet,
/// The globs as `FileMask` masks for Find in Files (`{a,b}` expanded, as masks
/// split on commas), `None` when they cannot be expressed.
masks: Option<(Vec<String>, Vec<String>)>,
/// The folders the included globs lie in, `None` when one may match anywhere (`**/a.rs`).
roots: Option<Vec<PathBuf>>,
}
impl PathScope {
fn new(root: &Path, patterns: &[String]) -> IdeResult<Self> {
pub(crate) fn of(call: &Call) -> IdeResult<Self> {
Self::new(call.root(), &call.project().content_roots(), &call.str_list("paths")?)
}
/// `attached`: the content roots, whose files outside `root` the globs name by absolute path.
fn new(root: &Path, attached: &[PathBuf], patterns: &[String]) -> IdeResult<Self> {
let (mut include, mut exclude) = (GlobSetBuilder::new(), GlobSetBuilder::new());
let (mut include_masks, mut exclude_masks) = (Vec::new(), Vec::new());
let mut roots = Vec::new();
let mut has_include = false;
let mut maskable = true;
let mut anywhere = false;
for raw in patterns {
let raw = raw.trim();
if raw.is_empty() {
@@ -362,12 +374,18 @@ impl PathScope {
Some(rest) => (true, rest.trim()),
None => (false, raw),
};
let mut glob = normalize_glob(pattern, root)?;
let mut glob = normalize_glob(pattern, root, attached)?;
// A path naming an existing directory covers the files below it.
if index_of_glob_char(&glob).is_none() && root.join(&glob).is_dir() {
glob.push_str("/**");
}
let alternatives = expand_braces(&glob);
if !negated {
match glob_folder(&glob, root) {
Some(folder) => roots.push(folder),
None => anywhere = true,
}
}
let alternatives = expand_braces(&engine_mask(&glob, attached));
maskable &= alternatives.is_some();
let (set, masks) =
if negated { (&mut exclude, &mut exclude_masks) } else { (&mut include, &mut include_masks) };
@@ -376,27 +394,83 @@ impl PathScope {
has_include |= !negated;
}
let build = |b: GlobSetBuilder| b.build().map_err(|e| IdeError::invalid(format!("Invalid glob pattern: {e}")));
// A folder inside another one is walked with it.
roots.sort();
roots.dedup_by(|inner, outer| inner.starts_with(outer));
Ok(Self {
root: root.to_path_buf(),
include: if has_include { Some(build(include)?) } else { None },
exclude: build(exclude)?,
masks: maskable.then_some((include_masks, exclude_masks)),
roots: (has_include && !anywhere).then_some(roots),
})
}
fn is_all(&self) -> bool {
pub(crate) fn is_all(&self) -> bool {
self.include.is_none() && self.exclude.is_empty()
}
/// `path` is project-relative with `/` (absolute outside the project).
fn matches(&self, path: &str) -> bool {
pub(crate) fn matches(&self, path: &str) -> bool {
self.include.as_ref().is_none_or(|s| s.is_match(path)) && !self.exclude.is_match(path)
}
pub(crate) fn matches_path(&self, path: &Path) -> bool {
self.is_all() || self.matches(&shown(&self.root, path))
}
/// Whether `dir` or a file in it is in: a directory something runs in.
pub(crate) fn matches_dir(&self, dir: &Path) -> bool {
if self.is_all() {
return true;
}
let dir = shown(&self.root, dir);
self.matches(&dir) || self.matches(&if dir.is_empty() { "x".into() } else { format!("{dir}/x") })
}
/// The folders to walk instead of the whole project, `None` when a glob may match anywhere.
pub(crate) fn roots(&self) -> Option<&[PathBuf]> {
self.roots.as_deref()
}
}
/// `path` as the tools give it: relative to `root` with `/`, absolute (with `/`) outside it.
fn shown(root: &Path, path: &Path) -> String {
path.strip_prefix(root).unwrap_or(path).to_string_lossy().replace('\\', "/")
}
/// The folder a normalized glob lies in (the whole segments before its first glob character),
/// `None` for one that may match anywhere.
fn glob_folder(glob: &str, root: &Path) -> Option<PathBuf> {
let end = index_of_glob_char(glob).map_or(glob.len(), |i| glob[..i].rfind('/').unwrap_or(0));
let prefix = glob[..end].trim_end_matches('/');
if prefix.is_empty() {
return None;
}
let path = root.join(prefix);
// A file named by its path lies in its folder.
Some(if index_of_glob_char(glob).is_none() && !path.is_dir() { path.parent()?.to_path_buf() } else { path })
}
/// `glob` as Find in Files matches it: a project attached outside the project goes by its
/// folder name there (as `search_project` shows its files), not by its absolute path.
fn engine_mask(glob: &str, attached: &[PathBuf]) -> String {
if is_absolute_pattern(glob) {
for root in attached {
let shown = root.to_string_lossy().replace('\\', "/");
if let Some(rest) = glob.strip_prefix(&shown).filter(|r| r.is_empty() || r.starts_with('/')) {
return format!("{}{rest}", root.file_name().unwrap_or_default().to_string_lossy());
}
}
}
glob.to_owned()
}
/// A glob as a project-relative pattern: `\` → `/`, leading `./` dropped, `dir/` → `dir/**`,
/// `name` → `**/name`, and its leading directories (`..`, absolute paths) resolved against
/// `root`. Errors when that points outside the project.
fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
/// `root`; absolute in a project of `attached` outside it. Errors when that points outside the
/// project.
fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
let mut value = raw.trim().replace('\\', "/");
if value.is_empty() {
return Err(IdeError::invalid("Glob pattern is empty"));
@@ -411,7 +485,7 @@ fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
if !value.contains('/') {
value = format!("**/{value}");
}
let value = normalize_path_pattern(&value, root)?;
let value = normalize_path_pattern(&value, root, attached)?;
if value.is_empty() {
return Err(IdeError::invalid(format!("Invalid glob pattern: {raw}")));
}
@@ -421,7 +495,7 @@ fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
/// Resolves the whole directory segments before the first glob character against `root`.
/// (JetBrains resolves up to the glob character itself, turning `src/Foo*.java` into
/// `src/Foo/*.java`; only whole segments are resolved here.)
fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
fn normalize_path_pattern(pattern: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
let outside = || {
IdeError::invalid(format!("Specified path '{pattern}' points to the location outside of the project directory"))
};
@@ -442,8 +516,16 @@ fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
} else {
root.join(prefix_path)
});
let relative = relative_to_root(root, &absolute).ok_or_else(outside)?;
let suffix = pattern[prefix_len..].trim_start_matches('/');
let Some(relative) = relative_to_root(root, &absolute) else {
// A project attached outside the project goes by its absolute path, as its files do.
let absolute = dunce::canonicalize(&absolute).unwrap_or(absolute);
if !attached.iter().any(|r| absolute.starts_with(r)) {
return Err(outside());
}
let absolute = absolute.to_string_lossy().replace('\\', "/");
return Ok(if suffix.is_empty() { absolute } else { format!("{absolute}/{suffix}") });
};
Ok(match (relative.is_empty(), suffix.is_empty()) {
(true, _) => suffix.to_owned(),
(false, true) => relative,
@@ -544,8 +626,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
let pattern = query(&call, if is_regex { "Regex pattern is empty" } else { "Search text is empty" })?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let scope = PathScope::of(&call)?;
// Globs Find in Files cannot take are applied afterwards, so the engine must not
// stop at `limit` matches the filter may drop.
let (masks, max_matches) = match scope.masks.clone() {
@@ -565,22 +646,18 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
whole_word: false,
include,
exclude,
// Only `scope` is walked.
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
scope: SearchScope::Project,
max_matches,
context: Default::default(),
include_excluded: call.flag("includeExcluded", false)?,
};
if is_regex && let Err(e) = ide_search::match_ranges("", &query) {
return Err(IdeError::invalid(format!("Invalid regex pattern: {pattern} ({})", e.message)));
}
let (files, summary, timed_out) = run_search(&call, query.clone()).await?;
// Content roots outside the project are reported by absolute path.
let mut files: Vec<(String, FileMatches)> = files
.into_iter()
.filter(|f| dir.contains(&f.path.0))
.map(|f| (call.display(&f.path.0), f))
.filter(|(path, _)| scope.matches(path))
.collect();
let mut files: Vec<(String, FileMatches)> =
files.into_iter().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
files.sort_by(|a, b| a.0.cmp(&b.0));
// Only these can match a line break.
let may_span = is_regex || pattern.contains('\n');
@@ -750,27 +827,35 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
async fn file_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Glob pattern is empty")?;
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let scope = PathScope::of(&call)?;
let include_excluded = call.flag("includeExcluded", false)?;
let glob = GlobSetBuilder::new()
.add(build_glob(&normalize_glob(&q, call.root())?)?)
.add(build_glob(&normalize_glob(&q, call.root(), &[])?)?)
.build()
.map_err(|_| IdeError::invalid(format!("Invalid glob pattern: {q}")))?;
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
let root = call.root().to_path_buf();
// `scope`, or the project folder and the content roots its walk does not cover: those
// outside it and those inside it that it skips as ignored.
let roots: Vec<PathBuf> = match dir.dir() {
Some(dir) => vec![dir.to_path_buf()],
let content = call.project().content_roots();
// Where a folder's exclusions are matched from: the content root holding it, or the project.
let base_of =
|dir: &Path| content.iter().filter(|r| dir.starts_with(r)).max_by_key(|r| r.components().count()).cloned();
// The folders of `paths`, or the project folder and the content roots its walk does not
// cover: those outside it and those inside it that it skips as ignored.
let roots: Vec<(PathBuf, PathBuf)> = match scope.roots() {
Some(dirs) => dirs
.iter()
.filter(|d| d.is_dir())
.map(|d| (d.clone(), base_of(d).unwrap_or_else(|| root.clone())))
.collect(),
None => std::iter::once(root.clone())
.chain(
call.project()
.content_roots()
.into_iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
content
.iter()
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r))
.cloned(),
)
.map(|r| (r.clone(), r))
.collect(),
};
let host = call.host();
@@ -790,7 +875,7 @@ async fn file_search(call: Call) -> IdeResult<Output> {
let (paths, more, timed_out) = host
.blocking(move || {
let mut found = Vec::new();
let more = roots.iter().any(|base| walk.dir(base, base, &mut found));
let more = roots.iter().any(|(dir, base)| walk.dir(dir, base, &mut found));
if walk.cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
@@ -877,23 +962,23 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let q = query(&call, "Search query is empty")?;
let (page, limit) = page(&call, SYMBOL_SEARCH_DEFAULT_LIMIT)?;
let around = context(&call)?;
let dir = Scope::of(&call)?;
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
let scope = PathScope::of(&call)?;
let external = call.flag("include_external", false)?;
let host = call.host();
let project = call.project().clone();
let indexing_before = project.index.status().indexing;
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
let found = {
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
let (project, q, within) = (project.clone(), q.clone(), scope.clone());
host.blocking(move || {
Ok(match dir {
Ok(if within.is_all() {
project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool)
} else {
// Filtered in the index: a pool cut before the filter could miss every match.
Some(dir) => project
project
.index
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
.unwrap_or_default(),
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| within.matches_path(p), &|| false)
.unwrap_or_default()
})
})
.await?
@@ -902,7 +987,6 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
.into_iter()
// By the path the other tools give: the index shows a root outside the project by its
// folder name, which is no path to read.
.filter(|s| dir.contains(&s.path.0))
.map(|s| (call.display(&s.path.0), s))
.filter(|(path, _)| scope.matches(path))
.map(|(path, s)| SearchItem {
@@ -920,11 +1004,11 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
roots.extend(crate::mcp::tool::attached_projects(call.root()));
for (name, container, location) in symbols {
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
// are what was asked for.
// Project files (attached projects' too) obey `paths`; library symbols are what was
// asked for.
let inside = location.uri.is_none()
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
if inside && !scope.matches(&path) {
continue;
}
let item = SearchItem {
@@ -999,13 +1083,13 @@ mod tests {
}
fn scope(root: &Path, p: &[&str]) -> PathScope {
PathScope::new(root, &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
PathScope::new(root, &[], &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
}
#[test]
fn normalizes_globs() {
let (_dir, root) = root();
let n = |p: &str| normalize_glob(p, &root);
let n = |p: &str| normalize_glob(p, &root, &[]);
assert_eq!(n("*.rs").unwrap(), "**/*.rs");
assert_eq!(n("./foo/bar.txt").unwrap(), "foo/bar.txt");
assert_eq!(n("foo/").unwrap(), "foo/**");
@@ -1082,9 +1166,33 @@ mod tests {
assert!(s.matches("a.rs") && !s.matches("docs/a.md"));
assert!(scope(root, &["*.{rs,ts}"]).masks.is_some());
assert!(scope(root, &["*.{rs,{ts,js}}"]).masks.is_none());
let err = |p: &str| PathScope::new(root, &[p.to_owned()]).err().unwrap().message;
let err = |p: &str| PathScope::new(root, &[], &[p.to_owned()]).err().unwrap().message;
assert!(err("a[").contains("Invalid glob pattern"));
assert!(err("!").contains("Exclude pattern is empty"));
assert!(err("../x/**").contains("outside of the project directory"));
}
#[test]
fn paths_name_the_folders_to_walk_and_projects_attached_outside() {
let (dir, root) = root();
let roots = |p: &[&str]| scope(&root, p).roots().map(<[PathBuf]>::to_vec);
// Only the folders the globs lie in, a folder inside another one walked with it.
assert_eq!(roots(&["subdir1/**", "subdir1/nested/*.rs", "!**/gen/**"]), Some(vec![root.join("subdir1")]));
assert_eq!(roots(&["subdir1/nested/x.rs"]), Some(vec![root.join("subdir1/nested")]));
// A glob matching anywhere, or none included, means the whole project.
assert_eq!(roots(&["subdir1/**", "**/*.rs"]), None);
assert_eq!(roots(&["!**/*.md"]), None);
let attached = dunce::canonicalize(dir.path()).unwrap().join("attached");
std::fs::create_dir_all(attached.join("src")).unwrap();
let shown = attached.to_string_lossy().replace('\\', "/");
let s = PathScope::new(&root, std::slice::from_ref(&attached), &[format!("{shown}/src/**")]).unwrap();
assert!(s.matches(&format!("{shown}/src/a.rs")) && !s.matches("src/a.rs"));
assert!(s.matches_path(&attached.join("src/a.rs")));
assert_eq!(s.roots(), Some(&[attached.join("src")][..]));
// Find in Files shows such a project's files under its folder name.
assert_eq!(s.masks.unwrap().0, ["attached/src/**"]);
let unattached = PathScope::new(&root, &[], &[format!("{shown}/src/**")]);
assert!(unattached.err().unwrap().message.contains("outside of the project directory"));
}
}
+8 -8
Переглянути файл
@@ -214,7 +214,7 @@ pub fn find_references() -> Tool {
Tool::new("find_references", "Find references using the language service and the IDE's project index. Positions are 1-based UTF-16. Reports incomplete results when analysis is still running.", |call| async move {
let path = call.resolve_readable(&call.str("filePath")?).await?;
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
let dir = super::scope::Scope::of(&call)?;
let paths = super::search::PathScope::of(&call)?;
let opened = open_at(&call, path).await?;
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, opened.doc, opened.pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
@@ -237,8 +237,8 @@ pub fn find_references() -> Tool {
if let serde_json::Value::Object(map) = &mut value {
let mut list = |key: &str| match map.remove(key) { Some(serde_json::Value::Array(items)) => items, _ => Vec::new() };
let (mut locations, mut classified) = (list("locations"), list("classified"));
if dir.dir().is_some() {
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| dir.contains(std::path::Path::new(p)));
if !paths.is_all() {
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| paths.matches_path(std::path::Path::new(p)));
locations.retain(inside);
classified.retain(|c| inside(&c["location"]));
}
@@ -253,7 +253,7 @@ pub fn find_references() -> Tool {
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("includeDeclaration", ParamType::Boolean, "Include declarations (default true)"))
.param(super::scope::param())
.param(super::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "References to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
@@ -336,7 +336,7 @@ pub fn get_call_hierarchy() -> Tool {
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("direction", ParamType::String, "incoming (callers, default) or outgoing (callees)"))
.param(super::scope::param())
.param(super::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
@@ -354,7 +354,7 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
Some(_) => return Err(IdeError::invalid("direction must be incoming or outgoing")),
};
let page = super::page::Page::of(&call, CALLS_LIMIT)?;
let scope = super::scope::Scope::of(&call)?;
let paths = super::search::PathScope::of(&call)?;
let path = call.resolve_readable(&call.str("filePath")?).await?;
let opened = open_at(&call, path).await?;
let hierarchy_at = |pos| {
@@ -378,8 +378,8 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
}
result => result?,
};
if scope.dir().is_some() {
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
if !paths.is_all() {
found.items.retain(|i| i.uri.is_none() && paths.matches_path(&i.path.0));
}
let incomplete = found.incomplete;
let (mut root, items) = call_items(found, |p| call.display(p));
+20 -14
Переглянути файл
@@ -266,33 +266,39 @@ By default all Git repositories are returned.",
.map(|r| (r.root.into_path_buf(), r.head))
.collect();
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
let scope = super::scope::Scope::of(&call)?;
let paths = super::search::PathScope::of(&call)?;
let git = git_executable(&call);
// A repository asked for, or the one holding `scope`.
let target = match &wanted {
Some(wanted) => Some(call.resolve_inside(wanted)?),
None => scope.dir().map(Path::to_path_buf),
// The repository asked for, or those holding the folders of `paths`.
let targets: Vec<PathBuf> = match &wanted {
Some(wanted) => vec![call.resolve_inside(wanted)?],
None => paths.roots().map(<[PathBuf]>::to_vec).unwrap_or_default(),
};
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
None => repos,
Some(path) => {
let mut roots: Vec<(PathBuf, Option<String>)> = if targets.is_empty() {
repos
} else {
let mut picked: Vec<(PathBuf, Option<String>)> = Vec::new();
for path in targets {
// The innermost repository containing the path.
match innermost_repo(repos, &path) {
Some(repo) => vec![repo],
let repo = match innermost_repo(repos.clone(), &path) {
Some(repo) => repo,
None => match find_git_root(call.root(), &path) {
Some(root) => {
// JetBrains reads the branch of any repository it reports.
let (git, dir) = (git.clone(), root.clone());
let branch = host.blocking(move || Ok(read_branch(&git, &dir))).await?;
vec![(root, branch)]
(root, branch)
}
None => {
let shown = wanted.unwrap_or_else(|| call.display(&path));
let shown = wanted.clone().unwrap_or_else(|| call.display(&path));
return Err(IdeError::not_found(format!("No git repository found for path: {shown}")));
}
},
};
if !picked.iter().any(|p| p.0 == repo.0) {
picked.push(repo);
}
}
picked
};
roots.sort_by_key(|r| relative_to_project(&call, &r.0));
let mut repositories = Vec::new();
@@ -305,7 +311,7 @@ By default all Git repositories are returned.",
.map_err(|e| {
IdeError::internal(format!("Failed to get git status for repository '{rel}': {}", e.message))
})?;
entries.retain(|e| scope.contains(&root.join(e.path.trim_end_matches('/'))));
entries.retain(|e| paths.matches_path(&root.join(e.path.trim_end_matches('/'))));
let count = |f: fn(&StatusEntry) -> bool| entries.iter().filter(|e| f(e)).count();
let listed: Vec<Value> = entries
.iter()
@@ -352,7 +358,7 @@ By default all Git repositories are returned.",
))
.param(Param::optional("includeUntracked", ParamType::Boolean, "Whether to include untracked files"))
.param(Param::optional("includeIgnored", ParamType::Boolean, "Whether to include ignored files"))
.param(super::scope::param())
.param(super::search::paths_param())
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, OFFSET))
}
+29 -7
Переглянути файл
@@ -3,6 +3,7 @@ use crate::Host;
use ide_command::command;
use ide_core::{IdeError, IdeResult, RequestId};
use ide_vfs::FileEntry;
use ide_workspace::DeletionUndo;
use std::path::{Path, PathBuf};
#[command(trust = always)]
@@ -163,14 +164,27 @@ pub fn fs_set_writable(host: &Host, window: &str, path: PathBuf, writable: bool)
/// Moving to the trash can take a while (large trees): kept off the main thread.
#[command(trust = always)]
pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
// Local History keeps the contents so deleted files can be restored.
let project = host.project(window).ok();
let history = project.as_ref().map(|p| p.history.clone());
delete_with_history(host, window, path, false).await.map(|_| ())
}
/// Moves an item to the Trash and returns the snapshot for Project View Undo.
#[command(trust = always)]
pub async fn fs_delete_with_undo(host: &Host, window: &str, path: PathBuf) -> IdeResult<DeletionUndo> {
delete_with_history(host, window, path, true).await
}
async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable: bool) -> IdeResult<DeletionUndo> {
let project = if undoable { Some(host.project(window)?) } else { host.project(window).ok() };
host.blocking(move || {
let paths = ide_workspace::file_ops::deletion_paths(&path)?;
if let Some(h) = history {
for p in &paths {
h.record_deletion(p, DELETE_SNAPSHOT_LIMIT);
let mut undo = DeletionUndo::default();
if let Some(p) = &project {
if undoable {
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
} else {
for pth in &paths {
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
}
}
}
ide_workspace::file_ops::delete(&path)?;
@@ -178,11 +192,17 @@ pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()
if let Some(p) = project {
let _ = p.with_backend_of(&path, |r| r.files_deleted(&paths));
}
Ok(())
Ok(undo)
})
.await
}
#[command(trust = always)]
pub async fn fs_undo_delete(host: &Host, window: &str, undo: DeletionUndo) -> IdeResult<Vec<ide_core::IpcPath>> {
let project = host.project(window)?;
host.blocking(move || Ok(project.history.restore_deletion_undo(undo))).await
}
#[command(trust = always)]
pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
let project = host.project(window).ok();
@@ -280,9 +300,11 @@ ide_command::domain!(
fs_create_file,
fs_create_file_bytes,
fs_delete,
fs_delete_with_undo,
fs_entry_kind,
fs_read_dir,
fs_read_text,
fs_rename,
fs_set_writable,
fs_undo_delete,
);
+26
Переглянути файл
@@ -68,6 +68,31 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
/// The files of a custom scope (`file:src//*.ts`), for the Project view's scope panes.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ScopeFiles {
pub paths: Vec<IpcPath>,
/// More files than `limit` matched; `paths` holds the first ones.
pub truncated: bool,
}
#[command(trust = always)]
pub async fn scope_files(host: &Host, window: &str, pattern: String, limit: u32) -> IdeResult<ScopeFiles> {
let project = host.project(window)?;
blocking(move || {
let mask = ide_search::FileMask::new(&[], &project.search_excludes())?;
let scope = ide_search::SearchScope::Pattern { pattern };
let mut files =
ide_search::scope_files(&project.root, &scope, &mask, None, &ide_core::CancellationToken::new())?;
files.sort_by(|a, b| a.rel_path.cmp(&b.rel_path));
let truncated = files.len() > limit as usize;
files.truncate(limit as usize);
Ok(ScopeFiles { paths: files.into_iter().map(|f| f.path.into()).collect(), truncated })
})
.await
}
/// Folders holding indexed files, for `@` references.
#[command(trust = always)]
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
@@ -375,6 +400,7 @@ ide_command::domain!(
path_completions,
recent_files,
remove_recent,
scope_files,
web_goto,
web_unresolved_references,
);
+9
Переглянути файл
@@ -302,6 +302,15 @@ pub fn set_settings(
}
});
}
// Directory Mappings change which repositories the project has.
if key == "vcs" || key == "vcs.mappings" || key.starts_with("vcs.mappings.") {
let affected = affected();
host.runtime.spawn_blocking(move || {
for project in affected {
project.refresh_repositories();
}
});
}
if key == "ssh" || key.starts_with("ssh.") {
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
+12 -5
Переглянути файл
@@ -34,8 +34,10 @@ pub async fn search_start(
) -> IdeResult<()> {
let project = host.project(window)?;
// Excluded roots (Project Structure marks and detected `target`, `node_modules`, …) and
// ignored names are never searched.
query.exclude.extend(project.search_excludes());
// ignored names are not searched, unless the query asks for them.
if !query.include_excluded {
query.exclude.extend(project.search_excludes());
}
let cancel = host.begin_request(request);
let events = on_event.clone();
let syntax = host.syntax();
@@ -80,10 +82,15 @@ pub(crate) fn search_project(
query.scope,
ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. }
));
let content_roots = match query.scope {
let content_roots: Vec<std::path::PathBuf> = match query.scope {
ide_search::SearchScope::Project
| ide_search::SearchScope::FileSet { .. }
| ide_search::SearchScope::Pattern { .. } => project.content_roots(),
| ide_search::SearchScope::Pattern { .. } => project
.content_roots()
.into_iter()
// Kept out of the root's walk only by its ignore rules, which this search does not apply.
.filter(|r| !(query.include_excluded && include_root && r.starts_with(root)))
.collect(),
_ => within.into_iter().collect(),
};
let filter = |rel: &str| match set {
@@ -144,7 +151,7 @@ pub(crate) fn search_project(
/// Project-relative `masks` (each a comma-separated list) for a search from the content root
/// shown as `prefix`: paths below it lose the prefix, other paths can match nothing there and
/// are dropped, names and `**/` patterns (`*.rs`, `**/build/**`) stay as they are.
fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
pub(crate) fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
let prefix = format!("{}/", prefix.trim_end_matches('/'));
masks
.iter()
+2
Переглянути файл
@@ -18,6 +18,7 @@ pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>>
}
for r in repos.all() {
r.set_ignored_names(settings.ignored_names());
r.set_cli_status(settings.vcs.git.cli_status);
}
repos.status()
})
@@ -40,6 +41,7 @@ pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::P
}
for r in repos.all() {
r.set_ignored_names(settings.ignored_names());
r.set_cli_status(settings.vcs.git.cli_status);
}
repos.status_paths(&paths)
})
+25
Переглянути файл
@@ -338,6 +338,13 @@ fn keep_private(root: &Path) {
}
}
/// Directory Mappings: the repository roots detection finds, before any are excluded or added.
#[command(trust = always)]
pub async fn vcs_detected_roots(host: &Host, window: &str) -> IdeResult<Vec<PathBuf>> {
let project = host.project(window)?;
blocking(move || project.detected_repository_roots()).await
}
/// The project's repositories, the primary one first.
#[command(trust = always)]
pub fn vcs_roots(host: &Host, window: &str) -> IdeResult<Vec<VcsRoot>> {
@@ -1061,6 +1068,22 @@ pub async fn vcs_config_get(
blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.config_get(&key))).await
}
/// Git User Name Is Not Defined: sets `user.name` / `user.email` for commits in the
/// repository, or globally.
#[command(trust = trusted)]
pub async fn vcs_set_user_identity(
host: &Host,
window: &str,
repo: Option<PathBuf>,
name: String,
email: String,
global: bool,
) -> IdeResult<()> {
host.require_trust(window)?;
let project = host.project(window)?;
blocking(move || project.with_repo_at(repo.as_deref(), |r| r.set_user_identity(&name, &email, global))).await
}
/// Local history operation that may take a while (hooks, large checkouts); git's
/// output streams through `on_output`. Cancellable.
#[command(trust = trusted)]
@@ -1569,6 +1592,7 @@ ide_command::domain!(
vcs_compare_paths,
vcs_compare_scope,
vcs_config_get,
vcs_set_user_identity,
vcs_conflict_versions,
vcs_create_branch,
vcs_create_patch,
@@ -1616,6 +1640,7 @@ ide_command::domain!(
vcs_revision_files,
vcs_reword,
vcs_roots,
vcs_detected_roots,
vcs_shelf_delete,
vcs_shelf_diff,
vcs_shelf_import,
+50
Переглянути файл
@@ -568,6 +568,8 @@ pub(super) struct Shared {
/// (plugin, item id) → item, for windows opened later.
output: Mutex<BTreeMap<(String, String), String>>,
decorations: Mutex<BTreeMap<String, Vec<super::DecorationSet>>>,
/// plugin → its console highlight rules, in order.
console_rules: Mutex<BTreeMap<String, Vec<ide_plugin::ConsoleRule>>>,
status: Mutex<BTreeMap<(String, String), StatusItem>>,
setting_snapshots: Mutex<SettingSnapshots>,
window_status: Mutex<BTreeMap<(String, String, String), StatusItem>>,
@@ -648,6 +650,7 @@ impl Shared {
status: Mutex::default(),
output: Mutex::default(),
decorations: Mutex::default(),
console_rules: Mutex::default(),
window_status: Mutex::default(),
setting_snapshots: Mutex::default(),
contexts: Mutex::default(),
@@ -874,6 +877,9 @@ impl Shared {
if self.decorations.lock().remove(plugin).is_some() {
self.sink.emit(None, PluginEvent::DecorationsChanged { plugin_id: plugin.into(), sets: Vec::new() });
}
if self.console_rules.lock().remove(plugin).is_some() {
self.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: plugin.into(), rules: Vec::new() });
}
self.withdraw_prompts(plugin);
self.net_prompts.lock().remove(plugin);
self.session_net_hosts.lock().remove(plugin);
@@ -1706,6 +1712,18 @@ impl HostApi for PluginApi {
fn file_icon_decorations(&self, set: &str, items: Vec<(PathBuf, String)>) -> Result<(), HostError> {
self.set_file_icon_decorations(set, items)
}
fn console_rules(&self, rules: Vec<ide_plugin::ConsoleRule>) -> Result<(), HostError> {
let rules = super::console_rules::normalize(rules).map_err(HostError::Invalid)?;
let mut all = self.shared.console_rules.lock();
if rules.is_empty() {
all.remove(self.id());
} else {
all.insert(self.id().into(), rules.clone());
}
// Emitted under the lock so replacements cannot arrive out of order.
self.shared.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: self.id().into(), rules });
Ok(())
}
fn vcs_log(
&self,
root: &Path,
@@ -3276,6 +3294,7 @@ impl PluginWorkspace for HostWorkspace {
scope: ide_search::SearchScope::Project,
max_matches: limit.min(10_000).saturating_add(1),
context: Default::default(),
include_excluded: false,
};
query.exclude.extend(project.search_excludes());
let files = Mutex::new(Vec::new());
@@ -4441,6 +4460,9 @@ impl Shared {
pub(super) fn decoration_sets(&self) -> BTreeMap<String, Vec<super::DecorationSet>> {
self.decorations.lock().clone()
}
pub(super) fn console_rules(&self) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
self.console_rules.lock().clone()
}
}
#[cfg(test)]
@@ -4612,6 +4634,34 @@ mod workbench_tests {
assert!(api.shared.decoration_sets().is_empty());
}
#[test]
fn console_rules_replace_keep_the_last_valid_list_and_go_with_the_plugin() {
let dir = tempfile::tempdir().unwrap();
let api = api(dir.path(), false, None);
let rule = |pattern: &str| ide_plugin::ConsoleRule {
pattern: pattern.into(),
ignore_case: false,
foreground: Some("bright-yellow".into()),
background: Some("navy".into()),
styles: vec!["bold".into()],
whole_line: true,
enabled: true,
};
// No capability, and no trusted project, is needed: the rules read nothing.
api.console_rules(vec![rule(r"\[AUDIT\]"), rule(r"JOB-\d+")]).unwrap();
let rules = &api.shared.console_rules()["test"];
assert_eq!(rules.len(), 2);
assert_eq!((rules[0].foreground.as_deref(), rules[0].background.as_deref()), (Some("bright-yellow"), None));
assert!(matches!(api.console_rules(vec![rule("(a+)+b")]), Err(HostError::Invalid(_))));
assert_eq!(api.shared.console_rules()["test"].len(), 2);
api.console_rules(vec![rule("x")]).unwrap();
assert_eq!(api.shared.console_rules()["test"].len(), 1);
api.console_rules(Vec::new()).unwrap();
assert!(api.shared.console_rules().is_empty());
api.console_rules(vec![rule("x")]).unwrap();
api.shared.clear_plugin("test", true);
assert!(api.shared.console_rules().is_empty());
}
#[test]
fn decoration_styles_keep_the_severity_palette_the_editor_renders() {
// Inspection Lens colours typos and weak warnings with their own styles; the
// host must keep them, not silently drop them the way an unknown style is dropped.
+7
Переглянути файл
@@ -184,6 +184,12 @@ pub fn plugin_decoration_sets(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec
plugins.decoration_sets()
}
/// Every plugin's console highlight rules (later changes arrive as `consoleRulesChanged`).
#[command(trust = trusted)]
pub fn plugin_console_rules(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
plugins.console_rules()
}
/// Reports exactly one completion from the operation's launching window.
#[command(trust = trusted)]
pub fn plugin_finish_operation(
@@ -296,6 +302,7 @@ ide_command::domain!(
plugin_answer_prompt,
plugin_cancel_task,
plugin_choose_program,
plugin_console_rules,
plugin_content_tab_action,
plugin_context_keys,
plugin_debug_attach_target,
+325
Переглянути файл
@@ -0,0 +1,325 @@
//! Console highlight rules (API 1.12, `ui.set-console-rules`): validated here,
//! matched by the windows with JavaScript's backtracking `RegExp`. A rule is
//! refused unless its worst case on a line of [`LINE_LEN`] characters stays
//! within [`MAX_STEPS`] backtracking steps, estimated from its structure.
use ide_plugin::ConsoleRule;
use regex_syntax::hir::{Class, ClassUnicode, ClassUnicodeRange, Hir, HirKind, Look};
pub(crate) const MAX_RULES: usize = 100;
/// The characters of a line the windows match rules against (`src/ui/consoleRules.ts`).
const LINE_LEN: u64 = 2000;
/// About 4 · 2000², a few milliseconds of `RegExp` work for one line.
const MAX_STEPS: u64 = 4 * LINE_LEN * LINE_LEN;
const COLORS: &[&str] = &["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"];
const STYLES: &[&str] = &["bold", "italic", "underline", "strikethrough", "dim"];
/// Validates every rule and drops colours and styles this host doesn't know.
pub(crate) fn normalize(rules: Vec<ConsoleRule>) -> Result<Vec<ConsoleRule>, String> {
if rules.len() > MAX_RULES {
return Err(format!("at most {MAX_RULES} console rules"));
}
rules
.into_iter()
.enumerate()
.map(|(i, rule)| {
validate_pattern(&rule.pattern, rule.ignore_case).map_err(|e| format!("console rule {i}: {e}"))?;
let mut styles: Vec<String> = Vec::new();
for style in rule.styles {
if STYLES.contains(&style.as_str()) && !styles.contains(&style) {
styles.push(style);
}
}
Ok(ConsoleRule {
foreground: rule.foreground.filter(|c| known_color(c)),
background: rule.background.filter(|c| known_color(c)),
styles,
..rule
})
})
.collect()
}
fn known_color(name: &str) -> bool {
COLORS.contains(&name.strip_prefix("bright-").unwrap_or(name))
}
fn validate_pattern(pattern: &str, ignore_case: bool) -> Result<(), String> {
if pattern.is_empty() {
return Err("empty pattern".into());
}
if pattern.len() > super::icon_patterns::MAX_PATTERN_LEN {
return Err(format!("pattern {pattern:?} is too long (max {})", super::icon_patterns::MAX_PATTERN_LEN));
}
if let Some(construct) = super::icon_patterns::unsupported_construct(pattern) {
return Err(format!("pattern {pattern:?}: {construct} is not supported"));
}
let parse = |p: &str| {
regex_syntax::ParserBuilder::new()
.case_insensitive(ignore_case)
.build()
.parse(p)
.map_err(|e| format!("invalid pattern {pattern:?}: {e}"))
};
parse(pattern)?;
let hir = parse(&javascript_classes(pattern))?;
let anchored = starts_anchored(&hir);
let cost = cost(&hir, &ClassUnicode::empty(), true)
.map_err(|why| format!("pattern {pattern:?}: {why} is not supported"))?;
let starts = if anchored { 1 } else { LINE_LEN };
if cost.work.saturating_mul(starts) > MAX_STEPS {
return Err(format!(
"pattern {pattern:?} could take too long on a long line: avoid two repetitions that can match the same text (`.*a.*b`, `\\w+\\w+`); a class such as `[^)]*` often helps"
));
}
Ok(())
}
fn starts_anchored(hir: &Hir) -> bool {
match hir.kind() {
HirKind::Look(Look::Start) => true,
HirKind::Capture(c) => starts_anchored(&c.sub),
HirKind::Concat(items) => items.first().is_some_and(starts_anchored),
HirKind::Alternation(items) => items.iter().all(starts_anchored),
_ => false,
}
}
/// From one start: `ways` the expression can end (each a backtracking point for
/// what follows) and the `work` of trying them all when what follows fails.
/// `scan`: the work is one pass over a run of characters.
#[derive(Clone, Copy)]
struct Cost {
ways: u64,
work: u64,
scan: bool,
}
const ONE: Cost = Cost { ways: 1, work: 1, scan: false };
/// `follow`: the characters what comes after `hir` can start with (empty when
/// only assertions follow). `last`: nothing follows, so the first way to end is the match.
fn cost(hir: &Hir, follow: &ClassUnicode, last: bool) -> Result<Cost, &'static str> {
match hir.kind() {
HirKind::Empty | HirKind::Literal(_) | HirKind::Class(_) | HirKind::Look(_) => Ok(ONE),
HirKind::Capture(c) => cost(&c.sub, follow, last),
HirKind::Concat(items) => {
let mut total = Cost { ways: 1, work: 0, scan: false };
let mut fixed = false;
let mut scanned = None;
for (i, item) in items.iter().enumerate() {
let rest = &items[i + 1..];
// Nothing after this can fail: the first way to end is the match.
if last && rest.is_empty() && nullable(item) {
total.work = total.work.saturating_add(total.ways);
break;
}
let next = first_of_seq(rest, follow);
let c = cost(item, &next, last && rest.is_empty())?;
// In a run of single characters (`[Ee][Rr]…`) only the first one is tried each way,
// and runs of one way cover different parts of the line: one pass in all.
let single = c.ways == 1 && c.work == 1;
let rescan = c.scan && scanned == Some(total.ways);
if !(single && fixed) && !rescan {
total.work = total.work.saturating_add(total.ways.saturating_mul(c.work));
}
fixed = single;
if c.scan {
scanned = Some(total.ways);
}
total.ways = total.ways.saturating_mul(c.ways);
}
Ok(Cost { ways: total.ways, work: total.work.max(1), scan: false })
}
HirKind::Alternation(items) => items.iter().try_fold(Cost { ways: 0, work: 0, scan: false }, |acc, h| {
let c = cost(h, follow, last)?;
Ok(Cost { ways: acc.ways.saturating_add(c.ways), work: acc.work.saturating_add(c.work), scan: false })
}),
HirKind::Repetition(r) => match r.max {
None if matches!(r.sub.kind(), HirKind::Literal(_) | HirKind::Class(_)) => {
// A run that what follows can't start inside ends in one place.
let ways = if overlaps(&first(&r.sub), follow) { LINE_LEN } else { 1 };
Ok(Cost { ways, work: LINE_LEN, scan: true })
}
None => Err("a repeated group (`(…)*`, `(…)+`)"),
Some(max) => {
// Each copy may end in `c.ways` places, and the count itself may vary.
let c = cost(&r.sub, &union(&first(&r.sub), follow), false)?;
let ways = c.ways.saturating_pow(max).saturating_mul(u64::from(max - r.min) + 1);
Ok(Cost { ways, work: ways.saturating_mul(c.work).saturating_add(u64::from(max)), scan: false })
}
},
}
}
fn overlaps(a: &ClassUnicode, b: &ClassUnicode) -> bool {
let mut both = a.clone();
both.intersect(b);
!both.ranges().is_empty()
}
/// `pattern` with JavaScript's ASCII-only `\w` and `\d` (Rust's are Unicode), so that
/// `\W` and `\D` include letters such as `é` as they do where the rules run.
fn javascript_classes(pattern: &str) -> String {
let mut out = String::with_capacity(pattern.len());
let mut chars = pattern.chars();
while let Some(c) = chars.next() {
if c != '\\' {
out.push(c);
continue;
}
match chars.next() {
Some('w') => out.push_str("[0-9A-Za-z_]"),
Some('W') => out.push_str("[^0-9A-Za-z_]"),
Some('d') => out.push_str("[0-9]"),
Some('D') => out.push_str("[^0-9]"),
Some(next) => {
out.push('\\');
out.push(next);
}
None => out.push('\\'),
}
}
out
}
fn nullable(hir: &Hir) -> bool {
hir.properties().minimum_len() == Some(0)
}
/// The characters `hir` can start with (everything, for a byte class).
fn first(hir: &Hir) -> ClassUnicode {
match hir.kind() {
HirKind::Empty | HirKind::Look(_) => ClassUnicode::empty(),
HirKind::Literal(lit) => match std::str::from_utf8(&lit.0).ok().and_then(|s| s.chars().next()) {
Some(c) => ClassUnicode::new([ClassUnicodeRange::new(c, c)]),
None => any(),
},
HirKind::Class(Class::Unicode(class)) => class.clone(),
HirKind::Class(Class::Bytes(_)) => any(),
HirKind::Capture(c) => first(&c.sub),
HirKind::Repetition(r) => first(&r.sub),
HirKind::Concat(items) => first_of_seq(items, &ClassUnicode::empty()),
HirKind::Alternation(items) => items.iter().fold(ClassUnicode::empty(), |acc, h| union(&acc, &first(h))),
}
}
/// The characters a sequence can start with, then `follow` if it may match nothing.
fn first_of_seq(items: &[Hir], follow: &ClassUnicode) -> ClassUnicode {
let mut set = ClassUnicode::empty();
for item in items {
set = union(&set, &first(item));
if !nullable(item) {
return set;
}
}
union(&set, follow)
}
fn union(a: &ClassUnicode, b: &ClassUnicode) -> ClassUnicode {
let mut out = a.clone();
out.union(b);
out
}
fn any() -> ClassUnicode {
ClassUnicode::new([ClassUnicodeRange::new('\0', char::MAX)])
}
#[cfg(test)]
mod tests {
use super::*;
fn rule(pattern: &str) -> ConsoleRule {
ConsoleRule {
pattern: pattern.into(),
ignore_case: false,
foreground: Some("red".into()),
background: None,
styles: Vec::new(),
whole_line: false,
enabled: true,
}
}
fn err(pattern: &str) -> String {
validate_pattern(pattern, false).unwrap_err()
}
#[test]
fn accepts_typical_log_rules() {
for pattern in [
r"\[AUDIT\]",
r"\[(AUDIT|METRIC|TASK-FAIL)\]",
r"JOB-\d+",
r"Exception in thread .*",
r".*ERROR.*",
r"took \d+(\.\d+)?ms",
r"\d+\.\d+\.\d+\.\d+",
r"\w+@\w+\.com",
r"user=\S+\s+id=\d+",
r#"^\s*at [^(]*\([^)]*\)$"#,
r"^\[service-a\].*",
r"SELECT .* FROM",
r"\b(GET|POST|PUT|DELETE) /\S*",
r"\d+(\.\d+){0,3}",
r"\w+(-\w+){0,4}",
r"(ERROR|WARN)\b.*$",
] {
assert!(validate_pattern(pattern, false).is_ok(), "{pattern}: {:?}", validate_pattern(pattern, false));
assert!(validate_pattern(pattern, true).is_ok(), "{pattern} (ignore case)");
}
}
#[test]
fn rejects_patterns_that_backtrack_for_too_long() {
// Each takes seconds or more on a 2000-character line in V8.
assert!(err(r"(a+)+$").contains("repeated group"));
assert!(err(r"^(a|aa)+b$").contains("repeated group"));
assert!(err(r"a*a*a*b").contains("too long"));
assert!(err(r".*a.*b").contains("too long"));
assert!(err(r"\w+\w+!").contains("too long"));
assert!(err(r"^(a?){30}a{30}$").contains("too long"));
// A group before `$` or `\b` is not the end of the pattern: those can still fail.
assert!(err(r"(x(a+)*)$").contains("repeated group"));
assert!(err(r"(?:foo|x(a+)*)\b").contains("repeated group"));
assert!(err(r"^(x\w*\w*\w*)$").contains("too long"));
// JavaScript's `\W` matches `é` and `\D` matches `٣`, Rust's don't.
assert!(err(r"\W+é+!").contains("too long"));
assert!(err(r"[\D]+[٣]+!").contains("too long"));
assert!(validate_pattern(r"\\w+\\w+!", false).is_ok(), "an escaped backslash, then `w`");
assert!(validate_pattern(r"[0-9a-f]{32}", false).is_ok());
// Anchored, the same shape tries one start instead of every position.
assert!(validate_pattern(r"^\w+\w+!", false).is_ok());
assert!(err(r"^.*a.*b.*c").contains("too long"));
}
#[test]
fn rejects_constructs_javascript_reads_differently() {
for pattern in [r"(?i)error", r"(?P<n>a)", r"(?=a)", r"\Aerror", r"error\z", r"\p{L}", r"[[:alpha:]]"] {
assert!(err(pattern).contains("not supported"), "{pattern}");
}
assert!(err("(").contains("invalid pattern"));
assert!(err("").contains("empty"));
assert!(err(&"a".repeat(513)).contains("too long"));
}
#[test]
fn normalizing_keeps_known_colours_and_styles_and_bounds_the_list() {
let mut r = rule("x");
r.foreground = Some("bright-cyan".into());
r.background = Some("#ff0000".into());
r.styles = vec!["bold".into(), "blink".into(), "bold".into(), "dim".into()];
let out = normalize(vec![r, ConsoleRule { foreground: Some("teal".into()), ..rule("y") }]).unwrap();
assert_eq!(out[0].foreground.as_deref(), Some("bright-cyan"));
assert_eq!(out[0].background, None);
assert_eq!(out[0].styles, ["bold", "dim"]);
assert_eq!(out[1].foreground, None);
let e = normalize(vec![rule("ok"), rule(".*a.*b")]).unwrap_err();
assert!(e.starts_with("console rule 1:"), "{e}");
assert!(normalize(vec![rule("x"); MAX_RULES]).is_ok());
assert!(normalize(vec![rule("x"); MAX_RULES + 1]).unwrap_err().contains("at most 100"));
}
}
+1 -1
Переглянути файл
@@ -30,7 +30,7 @@ pub(crate) fn validate_pattern(pattern: &str) -> Result<(), String> {
}
}
fn unsupported_construct(pattern: &str) -> Option<&'static str> {
pub(crate) fn unsupported_construct(pattern: &str) -> Option<&'static str> {
if pattern.match_indices("(?").any(|(at, _)| !pattern[at + 2..].starts_with(':')) {
return Some("an inline flag, lookaround or named group");
}
+6
Переглянути файл
@@ -20,6 +20,7 @@ mod auth;
mod build_graph;
pub mod commands;
pub mod commit;
mod console_rules;
mod database;
mod dependencies;
pub(crate) mod diagnostics;
@@ -438,6 +439,11 @@ impl PluginHost {
self.shared.decoration_sets()
}
/// Every plugin's console highlight rules, for windows opening after they were set.
pub fn console_rules(&self) -> std::collections::BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
self.shared.console_rules()
}
/// Creates the host; call [`load_all`](Self::load_all) to load installed plugins.
pub fn new(plugins_dir: PathBuf, sink: Arc<dyn PluginEventSink>, limits: Limits) -> IdeResult<Self> {
std::fs::create_dir_all(&plugins_dir)?;
+1
Переглянути файл
@@ -144,6 +144,7 @@ pub fn forwarded(event: &PluginEvent) -> bool {
| PluginEvent::ContentTabReply { .. }
| PluginEvent::OpenDiff { .. }
| PluginEvent::DecorationsChanged { .. }
| PluginEvent::ConsoleRulesChanged { .. }
| PluginEvent::EditorOpen { .. }
| PluginEvent::EditorRanges { .. }
| PluginEvent::Notification { .. }
+3
Переглянути файл
@@ -241,6 +241,9 @@ pub enum PluginEvent {
/// Complete replacement of one plugin's project-scoped decorations.
#[serde(rename_all = "camelCase")]
DecorationsChanged { plugin_id: String, sets: Vec<DecorationSet> },
/// Complete replacement of one plugin's console highlight rules (empty: none).
#[serde(rename_all = "camelCase")]
ConsoleRulesChanged { plugin_id: String, rules: Vec<ide_plugin::ConsoleRule> },
/// Open a file in the invoking window.
EditorOpen { path: ide_core::IpcPath, selection: Option<ide_core::Range> },
/// Change selection or scrolling only in this window's already open editor.
+28 -3
Переглянути файл
@@ -2,6 +2,7 @@
//! watchers and the per-project services, opened by [`crate::Host::open_project`].
use crate::Host;
use ide_core::workflow_settings::VcsMappings;
use ide_core::{CancellationToken, IdeError, IdeEvent, IdeResult, LanguageId, SharedSink};
use ide_index::ProjectIndex;
use ide_language::{FileTypes, LanguageRegistry, SyntaxCache};
@@ -955,10 +956,27 @@ fn scan_repositories(
}
}
/// The repository containing `root` and those nested below it or below a content root.
/// The repository containing `root` and those nested below it or below a content root,
/// with the project's Directory Mappings applied.
/// The project-open scan and the watcher's rescan share these skip rules.
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path, trusted: bool) -> IdeResult<Repos> {
let ignored = settings.effective().ignored_names();
let settings = settings.effective();
let found = detect_repositories(root, &settings, build_cache, trusted)?;
let mappings = &settings.vcs.mappings;
if mappings.is_empty() {
return Ok(found);
}
let resolve = |list: &[String]| -> Vec<PathBuf> { list.iter().map(|p| VcsMappings::resolve(root, p)).collect() };
Ok(found.mapped(&resolve(&mappings.excluded), &resolve(&mappings.added), root))
}
fn detect_repositories(
root: &Path,
settings: &ide_core::settings::Settings,
build_cache: &Path,
trusted: bool,
) -> IdeResult<Repos> {
let ignored = settings.ignored_names();
let skip = |p: &Path| {
p.file_name().is_some_and(|n| {
let name = n.to_string_lossy();
@@ -968,11 +986,17 @@ fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Pa
})
};
let mut roots = vec![root.to_path_buf()];
roots.extend(content_roots(&settings.effective(), root, build_cache, trusted));
roots.extend(content_roots(settings, root, build_cache, trusted));
Repos::discover_roots(&roots, &skip)
}
impl Project {
/// The repository roots detection finds, before Directory Mappings exclude or add any.
pub fn detected_repository_roots(&self) -> IdeResult<Vec<PathBuf>> {
let settings = self.settings.effective();
Ok(detect_repositories(&self.root, &settings, &self.build_cache_dir(), self.is_trusted())?.roots())
}
pub fn refresh_repositories(&self) {
scan_repositories(
&self.root,
@@ -1076,6 +1100,7 @@ impl Project {
apply_git_executable(&settings);
}
repo.set_ignored_names(settings.ignored_names());
repo.set_cli_status(settings.vcs.git.cli_status);
f(repo)
}
+91 -16
Переглянути файл
@@ -284,6 +284,18 @@ async fn files_of_a_project_attached_outside_go_by_their_absolute_path_everywher
.map(|r| r["repositoryPathRelativeToProject"].as_str().unwrap())
.collect();
assert!(repos.contains(&shown("").trim_end_matches('/')), "{repos:?}");
// `paths` names such a project by its absolute path, in every tool.
let only = json!([format!("{}/src/**", shown(""))]);
let files = h.json("search_file", json!({"q":"*.rs","paths":only})).await;
assert_eq!(files["items"], json!([{ "filePath": shown("src/lib.rs") }]));
let text = h.json("search_text", json!({"q":"attached_marker","paths":only})).await;
assert_eq!(text["items"][0]["filePath"], shown("src/lib.rs"), "{text}");
let symbols = h.json("search_symbol", json!({"q":"attached_marker","paths":only})).await;
assert_eq!(symbols["items"][0]["filePath"], shown("src/lib.rs"), "{symbols}");
let status = h.json("git_status", json!({"paths":only})).await;
assert_eq!(status["repositories"].as_array().unwrap().len(), 1, "{status}");
assert_eq!(status["repositories"][0]["repositoryPathRelativeToProject"], shown("").trim_end_matches('/'));
}
#[tokio::test(flavor = "multi_thread")]
@@ -442,7 +454,7 @@ async fn git_status_and_diff_on_a_temporary_repository() {
}
#[tokio::test(flavor = "multi_thread")]
async fn scope_limits_the_query_tools_to_a_directory() {
async fn paths_limit_the_query_tools_to_folders() {
let h = Harness::new();
std::fs::create_dir_all(h.root.join("lib")).unwrap();
std::fs::write(h.root.join("lib/c.txt"), "needle\n").unwrap();
@@ -452,17 +464,20 @@ async fn scope_limits_the_query_tools_to_a_directory() {
out.dedup();
out
};
assert_eq!(paths(&h.json("search_text", json!({"q":"needle","scope":"lib"})).await), ["lib/c.txt"]);
assert_eq!(paths(&h.json("search_regex", json!({"q":"need.e","scope":"lib/"})).await), ["lib/c.txt"]);
assert_eq!(paths(&h.json("search_text", json!({"q":"needle","paths":["lib/"]})).await), ["lib/c.txt"]);
assert_eq!(paths(&h.json("search_regex", json!({"q":"need.e","paths":["lib/**"]})).await), ["lib/c.txt"]);
let absolute = h.root.join("src").to_string_lossy().into_owned();
assert_eq!(paths(&h.json("search_file", json!({"q":"*.txt","scope":absolute})).await), ["src/a.txt", "src/b.txt"]);
// Within the scope, `paths` narrows further.
assert_eq!(
paths(&h.json("search_text", json!({"q":"needle","scope":"src","paths":["**/b.txt"]})).await),
["src/b.txt"]
paths(&h.json("search_file", json!({"q":"*.txt","paths":[absolute]})).await),
["src/a.txt", "src/b.txt"]
);
assert!(h.error("search_text", json!({"q":"needle","scope":"missing"})).await.contains("is not a directory"));
assert!(h.error("search_text", json!({"q":"needle","scope":".."})).await.contains("outside the project"));
// Several folders at once, and exclusions.
assert_eq!(
paths(&h.json("search_text", json!({"q":"needle","paths":["src/**","lib/**","!**/a.txt"]})).await),
["lib/c.txt", "src/b.txt"]
);
let outside = h.error("search_text", json!({"q":"needle","paths":["../**"]})).await;
assert!(outside.contains("outside of the project directory"), "{outside}");
let git = |args: &[&str]| {
let output = std::process::Command::new("git").current_dir(&h.root).args(args).output().unwrap();
@@ -473,7 +488,7 @@ async fn scope_limits_the_query_tools_to_a_directory() {
git(&["-c", "user.name=Test", "-c", "[email protected]", "commit", "-m", "Initial"]);
std::fs::write(h.root.join("src/a.txt"), "changed\n").unwrap();
std::fs::write(h.root.join("lib/c.txt"), "changed\n").unwrap();
let status = h.json("git_status", json!({"scope":"lib"})).await;
let status = h.json("git_status", json!({"paths":["lib/"]})).await;
assert_eq!(status["repositories"].as_array().unwrap().len(), 1);
assert_eq!(
status["repositories"][0]["entries"],
@@ -482,7 +497,63 @@ async fn scope_limits_the_query_tools_to_a_directory() {
}
#[tokio::test(flavor = "multi_thread")]
async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
async fn excluded_and_ignored_folders_are_searched_when_asked_for() {
let h = Harness::new();
// `ignored/` is ignored by the project's `.gitignore`; `excluded/` is excluded in its settings.
std::fs::create_dir_all(h.root.join("excluded")).unwrap();
std::fs::write(h.root.join("excluded/e.txt"), "needle\n").unwrap();
std::fs::create_dir_all(h.root.join("src/ignored")).unwrap();
std::fs::write(h.root.join("src/ignored/x.txt"), "needle\n").unwrap();
ide_host::ops::project::set_settings(
&h.host,
"main",
ide_workspace::settings::SettingsScope::Project,
"projectStructure.excluded",
"[\"excluded\"]",
)
.unwrap();
let found = |args: Value| {
let h = &h;
async move {
let v = h.json(args["tool"].as_str().unwrap(), args["args"].clone()).await;
let mut out: Vec<String> = v["items"]
.as_array()
.cloned()
.unwrap_or_default()
.iter()
.map(|i| i["filePath"].as_str().unwrap().to_owned())
.collect();
out.sort();
out.dedup();
out
}
};
let text = |args: Value| json!({ "tool": "search_text", "args": args });
assert_eq!(found(text(json!({"q":"needle"}))).await, ["src/a.txt", "src/b.txt"]);
let every = ["excluded/e.txt", "ignored/a.txt", "src/a.txt", "src/b.txt", "src/ignored/x.txt"];
assert_eq!(found(text(json!({"q":"needle","includeExcluded":true}))).await, every);
assert_eq!(found(json!({"tool":"search_regex","args":{"q":"need.e","includeExcluded":true}})).await, every);
// `paths` only narrows: a folder the project leaves out stays out when named ...
let nothing: Vec<String> = Vec::new();
assert_eq!(found(text(json!({"q":"needle","paths":["ignored/"]}))).await, nothing);
assert_eq!(found(text(json!({"q":"needle","paths":["excluded/"]}))).await, nothing);
// ... and is searched, alone, when asked for.
assert_eq!(
found(text(json!({"q":"needle","paths":["ignored/","excluded/"],"includeExcluded":true}))).await,
["excluded/e.txt", "ignored/a.txt"]
);
let file = |dir: &str| json!({"tool":"search_file","args":{"q":"*.txt","paths":[dir],"includeExcluded":true}});
assert_eq!(found(file("excluded/")).await, ["excluded/e.txt"]);
assert_eq!(found(file("ignored/")).await, ["ignored/a.txt"]);
assert_eq!(found(text(json!({"q":"needle","paths":["src/"]}))).await, ["src/a.txt", "src/b.txt"]);
assert_eq!(
found(text(json!({"q":"needle","paths":["src/"],"includeExcluded":true}))).await,
["src/a.txt", "src/b.txt", "src/ignored/x.txt"]
);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_symbol_search_with_paths_finds_matches_past_the_others() {
let h = Harness::new();
std::fs::create_dir_all(h.root.join("many")).unwrap();
for i in 0..60 {
@@ -498,12 +569,12 @@ async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
assert!(std::time::Instant::now() < deadline, "the files were never indexed");
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
let found = h.json("search_symbol", json!({"q":"pool_marker","scope":"zz","limit":1})).await;
let found = h.json("search_symbol", json!({"q":"pool_marker","paths":["zz/"],"limit":1})).await;
assert_eq!(found["items"][0]["filePath"], "zz/last.rs", "{found}");
}
#[tokio::test(flavor = "multi_thread")]
async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
async fn paths_reach_an_attached_worktree_the_repository_ignores() {
let h = Harness::new();
h.trust().await;
let git = |dir: &Path, args: &[&str]| {
@@ -545,10 +616,14 @@ async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
let everywhere = found(json!({"q":"needle"})).await;
assert!(everywhere.contains(&".wt/feature/src/b.txt".to_owned()), "{everywhere:?}");
assert_eq!(
found(json!({"q":"needle","scope":".wt/feature/src"})).await,
found(json!({"q":"needle","paths":[".wt/feature/src/"]})).await,
[".wt/feature/src/a.txt", ".wt/feature/src/b.txt"]
);
assert_eq!(found(json!({"q":"needle","paths":[".wt/feature/src/b.txt"]})).await, [".wt/feature/src/b.txt"]);
// With `includeExcluded` the root's walk enters the ignored worktree: its files still come once.
let all = h.json("search_text", json!({"q":"needle","includeExcluded":true})).await;
let items = all["items"].as_array().unwrap();
assert_eq!(items.iter().filter(|i| i["filePath"] == ".wt/feature/src/b.txt").count(), 1, "{all}");
}
#[cfg(unix)]
@@ -1217,8 +1292,8 @@ async fn call_hierarchy_pages_are_sorted_and_scoped() {
assert_eq!((&first["more"], &first["nextOffset"]), (&json!(true), &json!(2)));
let next = h.json("get_call_hierarchy", at(json!({"limit":2,"offset":2}))).await;
assert_eq!(names(&next), ["main"]);
let scoped = h.json("get_call_hierarchy", at(json!({"scope":"src"}))).await;
let scoped = h.json("get_call_hierarchy", at(json!({"paths":["src/"]}))).await;
assert_eq!(names(&scoped), ["main"]);
assert_eq!(scoped["total"], 1);
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the scope");
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the paths");
}
+44
Переглянути файл
@@ -121,6 +121,7 @@ impl PluginWorkspace for TestWorkspace {
scope: ide_search::SearchScope::Project,
max_matches: limit,
context: Default::default(),
include_excluded: false,
};
let files = Mutex::new(Vec::new());
let summary = ide_search::search(root, &query, &|_| None, cancel, &|file| files.lock().push(file))
@@ -4860,6 +4861,49 @@ fn plugins_set_their_own_context_keys() {
assert!(f.host.context_keys(Some("main")).is_empty(), "cleared when the plugin stops");
}
/// `ui.set-console-rules` (API 1.12) replaces the plugin's rules for every window without a
/// capability; unknown colours are dropped, an invalid rule keeps the previous list.
#[test]
fn plugins_replace_their_console_rules_and_lose_them_when_they_stop() {
let f = fixture(Limits::default());
f.install(&sample("jobs"));
f.take_events();
f.run("jobs", "console-rules", None).unwrap();
let changed: Vec<_> = f
.take_events()
.into_iter()
.filter_map(|(client, e)| match e {
PluginEvent::ConsoleRulesChanged { plugin_id, rules } => Some((client, plugin_id, rules)),
_ => None,
})
.collect();
assert_eq!(changed.len(), 1);
let (client, plugin_id, rules) = &changed[0];
assert_eq!((client.as_deref(), plugin_id.as_str()), (None, "jobs"));
assert_eq!(rules.iter().map(|r| r.pattern.as_str()).collect::<Vec<_>>(), [r"\[AUDIT\]", r"job-\d+"]);
assert!(
rules[0].whole_line && rules[0].styles == ["bold"] && rules[0].foreground.as_deref() == Some("bright-yellow")
);
assert!(rules[1].ignore_case && rules[1].foreground.as_deref() == Some("cyan") && rules[1].background.is_none());
assert_eq!(f.host.console_rules()["jobs"], *rules);
let err = f.run("jobs", "console-rules", Some("(a+)+b")).unwrap_err();
assert!(err.contains("invalid") && err.contains("repeated group"), "{err}");
assert!(f.run("jobs", "console-rules", Some(".*a.*b")).unwrap_err().contains("too long"));
assert_eq!(f.host.console_rules()["jobs"].len(), 2, "an invalid list keeps the previous one");
f.run("jobs", "console-rules", Some("")).unwrap();
assert!(f.host.console_rules().is_empty());
f.run("jobs", "console-rules", None).unwrap();
f.take_events();
f.host.set_enabled("jobs", false).unwrap();
assert!(f.host.console_rules().is_empty(), "cleared when the plugin stops");
assert!(f.take_events().iter().any(
|(_, e)| matches!(e, PluginEvent::ConsoleRulesChanged { plugin_id, rules } if plugin_id == "jobs" && rules.is_empty())
));
}
#[test]
fn context_keys_are_capped_and_windows_overlay_global_ones() {
let f = fixture(Limits::default());
+2
Переглянути файл
@@ -47,6 +47,7 @@ async fn find(host: &Host, paths: Vec<PathBuf>, pattern: &str) -> Vec<ide_search
scope: SearchScope::Files { paths: paths.into_iter().map(Into::into).collect() },
max_matches: 0,
context: Default::default(),
include_excluded: false,
},
ide_host::ops::Channel::new(move |event| {
if let search::SearchEvent::File { file } = event {
@@ -165,6 +166,7 @@ async fn properties_search_git_and_document_coordinates_agree() {
scope: SearchScope::Files { paths: vec![closed_path.clone().into()] },
max_matches: 0,
context: Default::default(),
include_excluded: false,
};
search::replace_in_files(
&host,
+128 -139
Переглянути файл
@@ -2,15 +2,12 @@
//! `ignore` crate) plus the user's `files.exclude` globs, below the project root
//! and the extra content roots (Project Structure).
//!
//! Like IDEA, ignored directories are left out entirely, while ignored files in
//! the remaining directories (`.env`) are listed by name only, so Go to File finds
//! them but their symbols stay out of the index.
//! Git-ignored files and folders are listed by name only: Go to File finds them
//! without reading their contents or indexing their symbols. Excluded folders
//! (including project-model outputs and dependencies) are not walked at all.
use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
use ignore::gitignore::{Gitignore, GitignoreBuilder};
use ignore::{WalkBuilder, WalkState};
use std::collections::HashMap;
use std::collections::hash_map::Entry;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc;
@@ -25,9 +22,6 @@ pub(crate) struct PathFilter {
/// Content roots outside `root`, indexed as `<folder name>/<path>`.
extra: Vec<ExtraRoot>,
excludes: GlobSet,
/// Root-level ignore files, for paths reported by the watcher (the walker
/// applies nested ignore files itself).
gitignore: Gitignore,
/// What the filter was built from: `(extra roots, exclude globs)`.
config: (crate::IndexRoots, Vec<String>),
}
@@ -36,25 +30,11 @@ struct ExtraRoot {
path: PathBuf,
/// Shown before the paths inside it (`shared-lib/src/x.rs`).
name: String,
gitignore: Gitignore,
}
fn root_ignores(root: &Path) -> Gitignore {
let mut gi = GitignoreBuilder::new(root);
for f in [".gitignore", ".ignore", ".git/info/exclude"] {
let path = root.join(f);
if path.is_file()
&& let Some(e) = gi.add(&path)
{
tracing::debug!("{}: {e}", path.display());
}
}
gi.build().unwrap_or_else(|_| Gitignore::empty())
}
/// Whether walking `root` leaves out `dir`, a folder below it: `dir` or a folder between
/// them is ignored (`.gitignore`, `.ignore`, `info/exclude`, the global excludes). Such a
/// folder can be a root of its own, with its own rules, without its files being walked twice.
/// Whether an ignore-aware content walk of `root` leaves out `dir` or an ancestor.
/// An ignored folder can be an explicit content root with its own ignore rules,
/// promoting its files from filename-only entries to indexable content.
pub fn walk_skips(root: &Path, dir: &Path) -> bool {
if dir == root || !dir.starts_with(root) || !dir.is_dir() {
return false;
@@ -150,14 +130,13 @@ impl PathFilter {
Ok(rel) if extra_roots.include_root => rel_string(rel),
_ => path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
};
extra.push(ExtraRoot { gitignore: root_ignores(&path), name, path });
extra.push(ExtraRoot { name, path });
}
Self {
root: root.to_owned(),
include_root: extra_roots.include_root,
extra,
excludes,
gitignore: root_ignores(root),
config: (extra_roots.clone(), exclude_globs.to_vec()),
}
}
@@ -170,7 +149,7 @@ impl PathFilter {
/// Stable fingerprint of the persisted-scope configuration; a start-up
/// snapshot is only trusted when this still matches.
pub(crate) fn stamp(&self) -> String {
let mut stamp = format!("include_root={}\n", self.config.0.include_root);
let mut stamp = format!("ignored_folders=names\ninclude_root={}\n", self.config.0.include_root);
for folder in &self.config.0.folders {
stamp.push_str(&folder.to_string_lossy());
stamp.push('\n');
@@ -203,13 +182,13 @@ impl PathFilter {
.chain(self.extra.iter().map(|e| e.path.as_path()))
}
/// The root containing `path`, its display prefix (`None` for the project root) and ignore rules.
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>, &Gitignore)> {
/// The root containing `path` and its display prefix (`None` for the project root).
fn base_of(&self, path: &Path) -> Option<(&Path, Option<&str>)> {
// An extra root inside the project root wins: its own rules apply below it.
if let Some(e) = self.extra.iter().find(|e| path.starts_with(&e.path)) {
return Some((e.path.as_path(), Some(e.name.as_str()), &e.gitignore));
return Some((e.path.as_path(), Some(e.name.as_str())));
}
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None, &self.gitignore))
(self.include_root && path.starts_with(&self.root)).then_some((self.root.as_path(), None))
}
/// Whether `path` is (at or) below one of the roots.
@@ -220,7 +199,7 @@ impl PathFilter {
/// `/`-separated path relative to its root, as displayed; paths in extra
/// content roots start with the root's folder name.
pub(crate) fn rel(&self, path: &Path) -> Option<String> {
let (base, prefix, _) = self.base_of(path)?;
let (base, prefix) = self.base_of(path)?;
let rel = rel_string(path.strip_prefix(base).ok()?);
if rel.is_empty() {
return None;
@@ -258,11 +237,10 @@ impl PathFilter {
ALWAYS_SKIP.contains(&name)
}
/// Whether a path reported by the watcher should be left out (outside the
/// root, excluded, or an ignored directory or inside one). Ignored files
/// elsewhere stay in, listed by name only.
pub(crate) fn is_excluded(&self, path: &Path, is_dir: bool) -> bool {
let Some((base, _, gitignore)) = self.base_of(path) else { return true };
/// Whether a path is outside the roots, VCS metadata, or explicitly excluded.
/// Git-ignore rules classify files as filename-only, not excluded.
pub(crate) fn is_excluded(&self, path: &Path) -> bool {
let Some((base, _)) = self.base_of(path) else { return true };
let rel = path.strip_prefix(base).map(rel_string).unwrap_or_default();
if rel.is_empty() {
return true;
@@ -280,32 +258,32 @@ impl PathFilter {
return true;
}
}
let dir = if is_dir { Some(path) } else { path.parent().filter(|p| *p != base) };
dir.is_some_and(|d| gitignore.matched_path_or_any_parents(d, true).is_ignore())
false
}
/// A filename walk: only explicit exclusions prune directories. Extra roots
/// inside another root are walked separately, with their own ignore rules.
fn walker(&self, dir: &Path) -> Option<WalkBuilder> {
let (root, _) = self.base_of(dir)?;
if dir != root && self.is_excluded(dir) {
return None;
}
let root = root.to_path_buf();
let excludes = self.excludes.clone();
let extra: Vec<PathBuf> = self.extra.iter().filter(|e| e.path != dir).map(|e| e.path.clone()).collect();
let mut builder = WalkBuilder::new(dir);
builder.standard_filters(false).follow_links(false).filter_entry(move |e| {
!Self::skip_name(&e.file_name().to_string_lossy())
&& !glob_excluded(&excludes, &root, e.path())
&& !extra.iter().any(|r| e.path() == r)
});
Some(builder)
}
/// All directories at or below `dir` that the index would walk, in walk order.
pub(crate) fn dirs(&self, dir: &Path) -> Vec<PathBuf> {
let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };
let root = root.to_path_buf();
let excludes = self.excludes.clone();
let walk_root = root.clone();
let walk_excludes = excludes.clone();
let walker = WalkBuilder::new(dir)
.hidden(false)
.parents(true)
.ignore(true)
.git_ignore(true)
.git_global(true)
.git_exclude(true)
.require_git(ide_core::ignored::inside_git_repo(dir))
.follow_links(false)
.filter_entry(move |e| {
let name = e.file_name().to_string_lossy();
!Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())
})
.build();
walker.flatten().filter(|e| e.file_type().is_some_and(|t| t.is_dir())).map(|e| e.into_path()).collect()
let Some(builder) = self.walker(dir) else { return Vec::new() };
builder.build().flatten().filter(|e| e.file_type().is_some_and(|t| t.is_dir())).map(|e| e.into_path()).collect()
}
/// All indexable files at or below `dir`, walked in parallel.
@@ -320,57 +298,35 @@ impl PathFilter {
}
fn walk_to(&self, dir: &Path, max_depth: Option<usize>, cancel: &AtomicBool) -> Vec<Found> {
let (tx, rx) = mpsc::channel::<Vec<Found>>();
let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };
let root = root.to_path_buf();
let excludes = self.excludes.clone();
let (walk_root, walk_excludes) = (root.clone(), excludes.clone());
let walker = WalkBuilder::new(dir)
let Some(mut builder) = self.walker(dir) else { return Vec::new() };
let Some((root, _)) = self.base_of(dir) else { return Vec::new() };
// Keep the matcher's root at the content root, even for a watcher scan
// starting inside an ignored folder, so ancestor rules still apply.
let matcher = WalkBuilder::new(root)
.hidden(false)
.parents(true)
.ignore(true)
.git_ignore(true)
.git_global(true)
.git_exclude(true)
.require_git(ide_core::ignored::inside_git_repo(dir))
.follow_links(false)
.max_depth(max_depth)
.filter_entry(move |e| {
let name = e.file_name().to_string_lossy();
!Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())
})
.build_parallel();
walker.run(|| {
let (root, excludes) = (&root, &excludes);
.require_git(ide_core::ignored::inside_git_repo(root))
.build_matchers()
.pop()
.expect("one content root");
let (tx, rx) = mpsc::channel::<Vec<Found>>();
builder.max_depth(max_depth).build_parallel().run(|| {
let mut matcher = matcher.clone();
let mut batch = Batch { tx: tx.clone(), items: Vec::with_capacity(256) };
Box::new(move |entry| {
if cancel.load(Ordering::Relaxed) {
return WalkState::Quit;
}
let Ok(entry) = entry else { return WalkState::Continue };
let Some(file_type) = entry.file_type() else { return WalkState::Continue };
if file_type.is_dir() && max_depth.is_none_or(|max| entry.depth() < max) {
// The walker drops ignored files unseen: list every file of a
// walked directory; those the walker doesn't report are ignored.
let Ok(children) = std::fs::read_dir(entry.path()) else { return WalkState::Continue };
for child in children.flatten() {
let path = child.path();
if child.file_type().is_ok_and(|t| t.is_file())
&& !Self::skip_name(&child.file_name().to_string_lossy())
&& !glob_excluded(excludes, root, &path)
&& let Ok(meta) = child.metadata()
{
batch.items.push(Found { path, mtime: mtime_of(&meta), size: meta.len(), ignored: true });
}
}
} else if file_type.is_file()
if entry.file_type().is_some_and(|t| t.is_file())
&& let Ok(meta) = entry.metadata()
&& let Ok(rel) = entry.path().strip_prefix(root)
{
let ignored = matcher.matched(rel, false).is_ignore();
batch.items.push(Found {
path: entry.into_path(),
mtime: mtime_of(&meta),
size: meta.len(),
ignored: false,
ignored,
});
}
if batch.items.len() >= 256 && batch.tx.send(std::mem::take(&mut batch.items)).is_err() {
@@ -380,17 +336,7 @@ impl PathFilter {
})
});
drop(tx);
// Each file comes once from its directory listing and, unless ignored, once from the walker.
let mut by_path: HashMap<PathBuf, Found> = HashMap::new();
for f in rx.into_iter().flatten() {
match by_path.entry(f.path.clone()) {
Entry::Occupied(mut e) => e.get_mut().ignored &= f.ignored,
Entry::Vacant(e) => {
e.insert(f);
}
}
}
by_path.into_values().collect()
rx.into_iter().flatten().collect()
}
}
@@ -435,23 +381,26 @@ mod tests {
touch(&root, f);
}
std::fs::write(root.join(".gitignore"), "build/\n").unwrap();
let filter =
PathFilter::new(&root, &vec![].into(), &["**/node_modules".into(), "target".into(), "docs/**".into()]);
let filter = PathFilter::new(
&root,
&vec![].into(),
&["**/node_modules".into(), "target".into(), "/build".into(), "docs/**".into()],
);
let mut found: Vec<String> =
filter.walk(&root, &AtomicBool::new(false)).iter().filter_map(|f| filter.rel(&f.path)).collect();
found.sort();
assert_eq!(found, vec![".github/workflows/ci.yml", ".gitignore", "src/a.rs", "src/deep/b.rs"]);
assert!(filter.is_excluded(&root.join("node_modules/y.js"), false));
assert!(filter.is_excluded(&root.join("a/target/z.rs"), false));
assert!(filter.is_excluded(&root.join("build/new.rs"), false));
assert!(filter.is_excluded(&root.join(".git/HEAD"), false));
assert!(filter.is_excluded(Path::new("/elsewhere/x.rs"), false));
assert!(!filter.is_excluded(&root.join("src/new.rs"), false));
assert!(filter.is_excluded(&root.join("node_modules/y.js")));
assert!(filter.is_excluded(&root.join("a/target/z.rs")));
assert!(filter.is_excluded(&root.join("build/new.rs")));
assert!(filter.is_excluded(&root.join(".git/HEAD")));
assert!(filter.is_excluded(Path::new("/elsewhere/x.rs")));
assert!(!filter.is_excluded(&root.join("src/new.rs")));
}
#[test]
fn ignored_files_are_listed_but_ignored_directories_are_not() {
fn ignored_files_and_directories_are_listed_by_name_only() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
for f in [
@@ -497,11 +446,15 @@ src/local/
let expected = [
(".env", true),
(".gitignore", false),
("build/nested/deep.rs", true),
("build/out.rs", true),
("logs/app.log", true),
("pkg/.gitignore", false),
("pkg/gen.rs", true),
("pkg/keep.rs", false),
("src/a.rs", false),
("src/debug.log", true),
("src/local/secrets.json", true),
];
assert_eq!(found, expected.map(|(p, i)| (p.to_owned(), i)));
@@ -514,18 +467,15 @@ src/local/
let top: Vec<String> = filter.list_dir(&root).iter().filter_map(|f| filter.rel(&f.path)).collect();
assert!(top.iter().all(|p| !p.contains('/')), "{top:?}");
for (rel, excluded) in [
(".env", false),
("src/new.log", false),
("src/new.rs", false),
("build/x.rs", true),
("logs/app.log", true),
("src/local/x.json", true),
] {
assert_eq!(filter.is_excluded(&root.join(rel), false), excluded, "{rel}");
for rel in
[".env", "src/new.log", "src/new.rs", "build/x.rs", "logs/app.log", "src/local/x.json", "build", "src"]
{
assert!(!filter.is_excluded(&root.join(rel)), "{rel}");
}
assert!(filter.is_excluded(&root.join("build"), true));
assert!(!filter.is_excluded(&root.join("src"), true));
let listed = filter.list_dir(&root.join("src/local"));
assert_eq!(listed.len(), 1);
assert_eq!(listed[0].path, root.join("src/local/secrets.json"));
assert!(listed[0].ignored);
}
#[test]
@@ -544,7 +494,7 @@ src/local/
let mut found: Vec<String> =
filter.walk(&root, &AtomicBool::new(false)).iter().filter_map(|f| filter.rel(&f.path)).collect();
found.sort();
assert_eq!(found, [".gitignore", "src/a.rs"]);
assert_eq!(found, [".gitignore", "out/x.rs", "src/a.rs"]);
}
#[test]
@@ -564,12 +514,12 @@ src/local/
.filter_map(|f| filter.rel(&f.path))
.collect();
found.sort();
assert_eq!(found, ["shared-lib/.gitignore", "shared-lib/src/b.rs", "src/a.rs"]);
assert_eq!(found, ["shared-lib/.gitignore", "shared-lib/out/x.rs", "shared-lib/src/b.rs", "src/a.rs"]);
assert_eq!(filter.store_key(&shared.join("src/b.rs")), None, "extra roots are not persisted");
assert_eq!(filter.store_key(&root.join("src/a.rs")).as_deref(), Some("src/a.rs"));
assert!(!filter.is_excluded(&shared.join("src/new.rs"), false));
assert!(filter.is_excluded(&shared.join("target/y.rs"), false));
assert!(filter.is_excluded(&shared.join("out/y.rs"), false));
assert!(!filter.is_excluded(&shared.join("src/new.rs")));
assert!(filter.is_excluded(&shared.join("target/y.rs")));
assert!(!filter.is_excluded(&shared.join("out/y.rs")));
assert!(filter.same_config(&vec![shared.clone(), root.join("src")].into(), &["target".into()]));
assert!(!filter.same_config(&vec![shared].into(), &["target".into()]));
}
@@ -598,10 +548,49 @@ src/local/
.filter_map(|f| filter.rel(&f.path))
.collect();
found.sort();
assert_eq!(found, [".wt/feature/.gitignore", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]);
assert_eq!(
found,
[".wt/feature/.gitignore", ".wt/feature/out/c.rs", ".wt/feature/src/b.rs", "lib/d.rs", "src/a.rs"]
);
assert_eq!(filter.store_key(&nested.join("src/b.rs")), None, "extra roots are not persisted");
assert!(!filter.is_excluded(&nested.join("src/new.rs"), false));
assert!(filter.is_excluded(&nested.join("out/new.rs"), false));
assert!(filter.is_excluded(&root.join(".wt/other/x.rs"), false));
assert!(!filter.is_excluded(&nested.join("src/new.rs")));
assert!(!filter.is_excluded(&nested.join("out/new.rs")));
assert!(!filter.is_excluded(&root.join(".wt/other/x.rs")));
let own_files = filter.walk(&nested, &AtomicBool::new(false));
assert!(!own_files.iter().find(|f| f.path == nested.join("src/b.rs")).unwrap().ignored);
assert!(own_files.iter().find(|f| f.path == nested.join("out/c.rs")).unwrap().ignored);
}
#[test]
fn explicit_exclusions_prune_filename_walks_and_watcher_subtrees() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
// The caller supplies files.exclude and the project model's anchored
// output/dependency/environment roots; ignored business folders stay in.
let excluded = ["node_modules", "jvm/build", "rust/target", ".venv", "python/__pycache__", "private"];
for folder in excluded {
touch(&root, &format!("{folder}/nested/hidden.ts"));
}
touch(&root, "notes/nested/todo.ts");
touch(&root, "internal/build/source.ts");
std::fs::write(root.join(".gitignore"), "notes/\ninternal/\n").unwrap();
let globs: Vec<String> = excluded.iter().map(|p| format!("/{p}")).collect();
let filter = PathFilter::new(&root, &vec![].into(), &globs);
let mut found = filter.walk(&root, &AtomicBool::new(false));
found.sort_by(|a, b| a.path.cmp(&b.path));
assert_eq!(
found.iter().map(|f| filter.rel(&f.path).unwrap()).collect::<Vec<_>>(),
[".gitignore", "internal/build/source.ts", "notes/nested/todo.ts"]
);
assert!(found[1..].iter().all(|f| f.ignored));
let dirs = filter.dirs(&root);
assert!(dirs.contains(&root.join("notes/nested")));
for folder in excluded {
let subtree = root.join(folder).join("nested");
assert!(filter.is_excluded(&subtree));
assert!(filter.walk(&subtree, &AtomicBool::new(false)).is_empty());
assert!(filter.list_dir(&subtree).is_empty());
assert!(!dirs.iter().any(|d| d.starts_with(root.join(folder))));
}
}
}
+139 -16
Переглянути файл
@@ -57,6 +57,15 @@ fn files(idx: &ProjectIndex, q: &str) -> Vec<String> {
idx.find_files(q, 20).into_iter().map(|m| m.rel_path).collect()
}
fn assert_filename_only(idx: &ProjectIndex, path: &str) {
assert!(files(idx, path).iter().any(|found| found == path), "{path} must be findable");
let data = idx.shared.data.read();
let entry = data.files.iter().flatten().find(|entry| entry.rel.as_ref() == path).unwrap();
assert!(entry.ignored, "{path} must remain classified as ignored");
assert_eq!(entry.hash, [0; 32], "{path} must not be content-hashed");
assert_eq!(entry.sym_len, 0, "{path} must not have symbols");
}
#[test]
fn exact_file_names_keep_all_source_candidates() {
let f = Fixture::new(&[
@@ -368,7 +377,7 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
let idx = fx.open();
assert_eq!(files(&idx, ".env"), vec![".env"], "the reported case: a git-ignored root file");
assert_eq!(files(&idx, "config.local"), vec!["src/config.local.ts"]);
assert!(files(&idx, "bundle").is_empty(), "ignored directories stay out");
assert_eq!(files(&idx, "bundle"), ["dist/bundle.js"]);
assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty(), "ignored files are listed by name only");
assert_eq!(symbols(&idx, "app", SymbolFilter::All), vec!["app"]);
@@ -379,7 +388,8 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "fresh.local"), vec!["src/fresh.local.ts"]);
assert!(symbols(&idx, "freshLocal", SymbolFilter::All).is_empty());
assert!(files(&idx, "more.js").is_empty());
assert_eq!(files(&idx, "more.js"), ["dist/more.js"]);
assert!(symbols(&idx, "more", SymbolFilter::All).is_empty());
// Nested ignore files apply to watcher updates as they do to the scan.
fx.write("pkg/.gitignore", "gen.ts\n");
@@ -406,6 +416,93 @@ fn go_to_file_finds_ignored_files_but_not_their_symbols() {
assert_eq!(files(&idx, "bundle"), vec!["dist/bundle.js"]);
}
#[test]
fn go_to_file_finds_files_in_ignored_folders() {
let fx = Fixture::new(&[
(".git/info/exclude", "/notes/\n"),
(".gitignore", "/local/\n"),
(".ignore", "/scratch/\n"),
("pkg/.gitignore", "private/\n"),
("notes/todo.ts", "export class IgnoredNote {}\n"),
("notes/deep/other.ts", "export class IgnoredOther {}\n"),
("local/config.ts", "export class IgnoredConfig {}\n"),
("scratch/draft.ts", "export class IgnoredDraft {}\n"),
("pkg/private/data.ts", "export class IgnoredData {}\n"),
("pkg/public.ts", "export class PublicThing {}\n"),
("node_modules/dep.ts", "export class Dependency {}\n"),
("target/gen.ts", "export class Generated {}\n"),
]);
std::fs::create_dir(fx.root.join("notes/empty")).unwrap();
let idx = fx.open();
for path in ["notes/todo.ts", "notes/deep/other.ts", "local/config.ts", "scratch/draft.ts", "pkg/private/data.ts"] {
assert_filename_only(&idx, path);
}
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
assert_eq!(symbols(&idx, "PublicThing", SymbolFilter::Types), ["PublicThing"]);
assert!(files(&idx, "node_modules/dep.ts").is_empty());
assert!(files(&idx, "target/gen.ts").is_empty());
let fresh = fx.write("pkg/private/new.ts", "export class IgnoredFresh {}\n");
fx.write("notes/new/deep.ts", "export class IgnoredDeep {}\n");
let dependency = fx.write("node_modules/new.ts", "export class DependencyFresh {}\n");
idx.update(&[fresh.clone(), fx.root.join("notes/new"), dependency], &[]);
assert!(idx.wait_idle(WAIT));
assert_filename_only(&idx, "pkg/private/new.ts");
assert_filename_only(&idx, "notes/new/deep.ts");
assert!(files(&idx, "node_modules/new.ts").is_empty());
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
std::fs::remove_file(&fresh).unwrap();
std::fs::remove_dir_all(fx.root.join("notes/deep")).unwrap();
idx.update(&[], &[fresh, fx.root.join("notes/deep")]);
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "pkg/private/new.ts").is_empty());
assert!(files(&idx, "notes/deep/other.ts").is_empty());
drop(idx);
// New files in populated and previously empty ignored directories invalidate the manifest.
let idx = fx.open();
assert_eq!(files(&idx, "notes/todo.ts"), ["notes/todo.ts"]);
drop(idx);
fx.write("notes/offline.ts", "export class IgnoredOffline {}\n");
fx.write("notes/empty/offline.ts", "export class IgnoredEmptyOffline {}\n");
let idx = fx.open();
assert_filename_only(&idx, "notes/offline.ts");
assert_filename_only(&idx, "notes/empty/offline.ts");
assert!(symbols(&idx, "Ignored", SymbolFilter::All).is_empty());
}
#[test]
fn explicit_content_roots_keep_their_own_ignored_files_filename_only() {
let fx = Fixture::new(&[("src/app.ts", "export class App {}\n")]);
let shared = fx._dir.path().join("shared");
std::fs::create_dir_all(shared.join("private")).unwrap();
std::fs::create_dir_all(shared.join("node_modules")).unwrap();
std::fs::write(shared.join(".ignore"), "private/\n").unwrap();
std::fs::write(shared.join("private/local.ts"), "export class SharedIgnored {}\n").unwrap();
std::fs::write(shared.join("public.ts"), "export class SharedPublic {}\n").unwrap();
std::fs::write(shared.join("node_modules/dep.ts"), "export class SharedDependency {}\n").unwrap();
let idx = fx.open();
idx.set_scope(vec![shared.clone()], vec!["**/node_modules".into(), "**/target".into()]);
assert!(idx.wait_idle(WAIT));
assert_filename_only(&idx, "shared/private/local.ts");
assert_eq!(symbols(&idx, "SharedPublic", SymbolFilter::Types), ["SharedPublic"]);
assert!(symbols(&idx, "SharedIgnored", SymbolFilter::All).is_empty());
assert!(files(&idx, "shared/node_modules/dep.ts").is_empty());
std::fs::create_dir(shared.join("private/new")).unwrap();
std::fs::write(shared.join("private/new/fresh.ts"), "export class SharedFresh {}\n").unwrap();
idx.update(&[shared.join("private/new")], &[]);
assert!(idx.wait_idle(WAIT));
assert_filename_only(&idx, "shared/private/new/fresh.ts");
assert!(symbols(&idx, "SharedFresh", SymbolFilter::All).is_empty());
std::fs::remove_dir_all(shared.join("private/new")).unwrap();
idx.update(&[], &[shared.join("private/new")]);
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "shared/private/new/fresh.ts").is_empty());
assert_filename_only(&idx, "shared/private/local.ts");
}
#[test]
fn second_window_on_same_project_works_in_memory() {
let fx = sample();
@@ -854,13 +951,19 @@ fn warm_start_detects_changed_ignore_rules() {
let f = Fixture::new(&[("sub/generated/a.rs", "fn a() {}\n"), (".git/HEAD", "ref: refs/heads/main\n")]);
f.write("sub/.gitignore", "");
let idx = f.open();
assert_eq!(idx.status().files, 2, "generated/a.rs plus .gitignore itself");
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
drop(idx);
std::thread::sleep(Duration::from_millis(20));
f.write("sub/.gitignore", "generated/\n");
let idx = f.open();
assert_eq!(idx.status().files, 1, "an updated ignore rule invalidates the warm snapshot");
assert_filename_only(&idx, "sub/generated/a.rs");
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "changed rules invalidate cached symbols");
drop(idx);
f.write("sub/.gitignore", "");
let idx = f.open();
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unchanged contents are parsed after unignoring");
}
#[test]
@@ -871,20 +974,24 @@ fn warm_start_detects_changed_ignore_rules_above_the_project() {
std::fs::create_dir_all(repo.join(".git/info")).unwrap();
std::fs::write(repo.join(".git/HEAD"), "ref: refs/heads/main\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 2);
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::fs::write(repo.join(".gitignore"), "proj/generated/\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 1, "a new ignore file above the project invalidates the warm snapshot");
assert_filename_only(&idx, "generated/a.rs");
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "new ancestor rules invalidate cached symbols");
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::thread::sleep(Duration::from_millis(20));
std::fs::write(repo.join(".gitignore"), "").unwrap();
std::fs::write(repo.join(".git/info/exclude"), "proj/src/\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 1, "so do the enclosing repository's changed rules");
assert!(!symbols(&idx, "a", SymbolFilter::All).is_empty());
assert_filename_only(&idx, "src/b.rs");
assert!(symbols(&idx, "b", SymbolFilter::All).is_empty());
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unignored contents are re-parsed unchanged");
}
#[test]
@@ -901,12 +1008,20 @@ fn warm_start_detects_a_changed_exclude_file_of_a_linked_worktree() {
std::fs::write(worktree.join("commondir"), "../..\n").unwrap();
std::fs::write(f.root.join(".git"), format!("gitdir: {}\n", worktree.display())).unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 2);
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"]);
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::fs::write(main.join("info/exclude"), "generated/\n").unwrap();
let idx = f.open();
assert_eq!(idx.status().files, 1, "the shared exclude file invalidates the warm snapshot");
assert_filename_only(&idx, "generated/a.rs");
assert!(symbols(&idx, "a", SymbolFilter::All).is_empty(), "shared exclude rules invalidate cached symbols");
assert_eq!(symbols(&idx, "b", SymbolFilter::All), ["b"]);
drop(idx);
std::fs::write(main.join("info/exclude"), "").unwrap();
let idx = f.open();
assert_eq!(symbols(&idx, "a", SymbolFilter::All), ["a"], "unignored contents are re-parsed unchanged");
}
#[test]
@@ -939,19 +1054,24 @@ fn rule_changes_refresh_only_the_affected_index_subtree() {
fx.write(rule, "");
let idx = fx.open();
assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
assert_eq!(symbols(&idx, "generated", SymbolFilter::All), ["generated"]);
assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
fx.write(rule, "generated/\nlocal.ts\n");
let dirs = [fx.root.join(subtree)];
idx.ignore_rules_changed(&dirs);
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "file.ts").is_empty(), "{rule}: ignored directory remained indexed");
assert_eq!(files(&idx, "local.ts"), ["sub/local.ts"]);
assert_filename_only(&idx, "sub/generated/file.ts");
assert!(symbols(&idx, "generated", SymbolFilter::All).is_empty(), "{rule}: ignored symbols remained indexed");
assert_filename_only(&idx, "sub/local.ts");
assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty());
assert_eq!(files(&idx, "keep.ts"), ["other/keep.ts"]);
assert_eq!(symbols(&idx, "keep", SymbolFilter::All), ["keep"]);
fx.write(rule, "");
idx.ignore_rules_changed(&dirs);
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
assert_eq!(symbols(&idx, "generated", SymbolFilter::All), ["generated"]);
assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
// The cached root matcher must also follow the rules for later watcher updates.
let fresh = fx.write("sub/generated/new.ts", "export function fresh() {}\n");
@@ -966,7 +1086,7 @@ fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
let fx = Fixture::new(&[
(".git/HEAD", "ref: refs/heads/main\n"),
(".git/info/exclude", ""),
("member/generated/item.txt", "x"),
("member/generated/item.rs", "fn member_item() {}\n"),
]);
let idx = ProjectIndex::open(
&fx.root,
@@ -979,15 +1099,18 @@ fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
)
.unwrap();
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
assert_eq!(files(&idx, "item.rs"), ["member/generated/item.rs"]);
assert_eq!(symbols(&idx, "member_item", SymbolFilter::All), ["member_item"]);
fx.write(".git/info/exclude", "generated/\n");
idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
assert!(idx.wait_idle(WAIT));
assert!(files(&idx, "item.txt").is_empty());
assert_filename_only(&idx, "member/generated/item.rs");
assert!(symbols(&idx, "member_item", SymbolFilter::All).is_empty());
fx.write(".git/info/exclude", "");
idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
assert!(idx.wait_idle(WAIT));
assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
assert_eq!(files(&idx, "item.rs"), ["member/generated/item.rs"]);
assert_eq!(symbols(&idx, "member_item", SymbolFilter::All), ["member_item"]);
}
#[test]
+1 -1
Переглянути файл
@@ -926,7 +926,7 @@ impl Shared {
continue;
}
let Ok(meta) = std::fs::symlink_metadata(&path) else { continue };
if filter.is_excluded(&path, meta.is_dir()) {
if filter.is_excluded(&path) {
continue;
}
if meta.is_dir() {
+4 -8
Переглянути файл
@@ -407,18 +407,14 @@ impl Peer {
let resolved = resolve_spawn_program(command, env);
let mut cmd = tokio::process::Command::new(&resolved);
// The working directory first: it picks the project's environment.
cmd.current_dir(cwd);
cmd.current_dir(cwd)
.envs(ide_core::process::shell_env_in(cwd))
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())));
ide_core::process::prepare(cmd.as_std_mut());
// Wrappers (`npx`, `codex.cmd`, launcher scripts) start the real server as a child:
// stopping the connection stops the whole tree.
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.envs(ide_core::process::shell_env_in(cwd))
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
cmd.args(args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true);
let mut child = cmd.spawn()?;
let stdin = child.stdin.take().ok_or_else(|| std::io::Error::other("child stdin unavailable"))?;
let stdout = child.stdout.take().ok_or_else(|| std::io::Error::other("child stdout unavailable"))?;
+1
Переглянути файл
@@ -23,6 +23,7 @@ pub(crate) mod configuration;
mod extract_interface;
mod formatter;
mod generated;
pub(crate) use generated::is_processor_output;
mod hierarchy;
pub(crate) mod jvm_inspect;
mod move_refactoring;
+26
Переглянути файл
@@ -25,6 +25,18 @@ pub(crate) struct GeneratedScan {
pub roots: Vec<GeneratedRoot>,
}
/// Whether `path` is in (or is) an annotation-processor output folder:
/// `generated-sources/annotations` or `generated-test-sources/test-annotations`. jdtls
/// runs the processors itself and writes there; javac (a Maven build) writes the same
/// files, and jdtls must not take those as edits (#4128).
pub(crate) fn is_processor_output(path: &Path) -> bool {
let parts: Vec<_> = path.components().map(|c| c.as_os_str()).collect();
parts.windows(2).any(|w| {
(w[0] == "generated-sources" && w[1] == "annotations")
|| (w[0] == "generated-test-sources" && w[1] == "test-annotations")
})
}
/// Generated Java source folders under `root` (a reactor or one module).
pub(crate) fn scan(root: &Path) -> GeneratedScan {
let mut modules = Vec::new();
@@ -260,6 +272,20 @@ fn plugins_removed(build: &str) -> String {
mod tests {
use super::*;
#[test]
fn recognizes_annotation_processor_output() {
for (path, expected) in [
("/p/m/target/generated-sources/annotations/com/x/FooMappingImpl.java", true),
("/p/m/target/generated-sources/annotations", true),
("/p/m/build-out/generated-test-sources/test-annotations/com/x/T.java", true),
("/p/m/target/generated-sources/protobuf/java/com/x/Hello.java", false),
("/p/m/src/main/java/annotations/Foo.java", false),
("/p/m/target/classes/com/x/FooMappingImpl.class", false),
] {
assert_eq!(is_processor_output(Path::new(path)), expected, "{path}");
}
}
fn write(root: &Path, rel: &str, text: &str) {
let path = root.join(rel);
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+4 -3
Переглянути файл
@@ -160,12 +160,13 @@ const DEAD_SHIM_MESSAGES: &[&str] =
/// server that dies like that on every start is missing (an install hint), not crashing.
/// Anything but a clear "not installed" answer from the shim counts as working.
fn reject_dead_shim(binary: PathBuf, search: &OsStr, root: &Path) -> Option<PathBuf> {
if !binary.parent().is_some_and(|d| d.file_name().is_some_and(|n| n == "shims")) {
if binary.parent().and_then(Path::file_name) != Some(OsStr::new("shims")) {
return Some(binary);
}
let Ok(mut child) = ide_core::process::prepare(std::process::Command::new(&binary).current_dir(root))
let mut cmd = std::process::Command::new(&binary);
cmd.current_dir(root).env("PATH", search);
let Ok(mut child) = ide_core::process::prepare(&mut cmd)
.arg("--version")
.env("PATH", search)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::piped())
+5
Переглянути файл
@@ -3057,7 +3057,12 @@ impl LspManager {
for s in servers {
let Some(run) = s.running() else { continue };
let open = open.get(&(s.id, run.generation)).filter(|_| run.caps.read().sync != SyncKind::None);
// jdtls owns its annotation-processor output; javac's copy of those files is not an edit.
let jdtls = s.name == "jdtls";
let send = |p: &PathBuf, change: Change| {
if jdtls && jdtls::is_processor_output(p) {
return false;
}
change == Change::Deleted
|| !open
.is_some_and(|paths| paths.contains(p) || canonical.get(p).is_some_and(|c| paths.contains(c)))
+1 -2
Переглянути файл
@@ -94,10 +94,9 @@ pub(crate) fn connect_or_start(
let args = substitute_args(&config.args, port, root);
let mut cmd = tokio::process::Command::new(binary);
cmd.current_dir(root);
cmd.current_dir(root).envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())));
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(&args)
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
+27
Переглянути файл
@@ -991,6 +991,33 @@ async fn files_changed_on_disk_reach_the_servers_of_their_language() {
h.mgr.shutdown_all().await;
}
/// jdtls runs the annotation processors itself and writes their output; a Maven build's
/// copy of those files must not reach it as an edit, or jdtls recompiles javac's copy and
/// overwrites its classes with broken ones (#4128).
#[tokio::test(flavor = "multi_thread")]
async fn jdtls_does_not_hear_of_annotation_processor_output() {
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
let (doc, _) = h.open("Open.java", "class Open {}");
h.wait_status("jdtls", ServerStatus::Ready).await;
let s = h.launcher.state("jdtls");
let source = h.root.join("m/src/main/java/com/x/FooMapping.java");
let generated = h.root.join("m/target/generated-sources/annotations/com/x/FooMappingImpl.java");
let test_generated = h.root.join("m/target/generated-test-sources/test-annotations/com/x/T.java");
h.mgr.watched_files_changed(
&[test_generated],
&[generated.clone(), source.clone()],
std::slice::from_ref(&generated),
&[h.root.join("m/target/generated-sources/annotations")],
);
eventually(|| !s.notified("workspace/didChangeWatchedFiles").is_empty()).await;
h.mgr.hover(doc, Pos::new(0, 0), Default::default()).await.unwrap();
assert_eq!(
s.notified("workspace/didChangeWatchedFiles"),
vec![json!({ "changes": [{ "uri": uri_of(&source), "type": 2 }] })]
);
h.mgr.shutdown_all().await;
}
/// An external change to a document open on the server's current instance reaches it only
/// through the reload's `didChange`: a watched-file change for it too would make a server
/// that re-reads the file on one (csharp-ls) apply the reload and then the diff computed
+6 -1
Переглянути файл
@@ -56,7 +56,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.11";
pub const API_VERSION: &str = "1.12";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
@@ -391,6 +391,11 @@ pub trait HostApi: Send + Sync {
let _ = (client, id, item);
Err(HostError::Invalid("window status unavailable".into()))
}
/// Replaces the plugin's console highlight rules (API 1.12); empty removes them.
fn console_rules(&self, rules: Vec<crate::ConsoleRule>) -> Result<(), HostError> {
let _ = rules;
Err(HostError::Failed("console rules unavailable".into()))
}
/// Sets (`Some`, validated JSON text) or removes the plugin's context key,
/// for window `client` (every window if `None`).
fn set_context(&self, client: Option<&str>, key: &str, value: Option<String>) -> Result<(), HostError> {
+16
Переглянути файл
@@ -72,6 +72,22 @@ pub struct StatusItem {
pub command: Option<String>,
}
/// A plugin's highlight rule for Run and Debug console output (API 1.12, `ui.set-console-rules`).
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct ConsoleRule {
pub pattern: String,
pub ignore_case: bool,
/// A console palette colour (`red`, `bright-blue`); `None` keeps the text's own.
pub foreground: Option<String>,
pub background: Option<String>,
/// `bold`, `italic`, `underline`, `strikethrough`, `dim`.
pub styles: Vec<String>,
/// The whole line, or only the matched text.
pub whole_line: bool,
pub enabled: bool,
}
/// An entry of a plugin's `pick` or `pick-many`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+15
Переглянути файл
@@ -506,6 +506,21 @@ impl ui::Host for StoreData {
.window_status_item(self.invocation.client.as_deref().expect("checked"), &clip(id, 64), None)
.map_err(to_wit))
}
fn set_console_rules(&mut self, rules: Vec<ui::ConsoleRule>) -> Fallible<()> {
let rules = rules
.into_iter()
.map(|r| crate::ConsoleRule {
pattern: r.pattern,
ignore_case: r.ignore_case,
foreground: r.foreground,
background: r.background,
styles: r.styles,
whole_line: r.whole_line,
enabled: r.enabled,
})
.collect();
Ok(self.host.console_rules(rules).map_err(to_wit))
}
fn set_context(&mut self, key: String, value: ui::ContextValue) -> Fallible<()> {
let valid_key =
(1..=64).contains(&key.len()) && key.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-'));
+17 -5
Переглянути файл
@@ -91,16 +91,28 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.11.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.11.0", "1.0.0-rc.1"]
{
let host = v("1.12.0");
for ok in [
"1.0.0",
"1.3.0",
"1.4.7",
"1.5.0",
"1.6.0",
"1.7.0",
"1.8.0",
"1.9.0",
"1.10.0",
"1.11.0",
"1.12.0",
"1.0.0-rc.1",
] {
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.12.0"), &host).unwrap_err();
let newer = check_api(&v("1.13.0"), &host).unwrap_err();
assert!(newer.contains("1.12") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.11 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.12 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ada68dfdf2875668eff1765ec22678315f18ac6f1364c5f7eda742cb58dc3c60
36b8ec8be8a65e60d601cd53e9ae0e8ab2865cb69de9b83ca31a9cb277aa0801
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
2279ae4f79c565c4cd59d9191f394c4d7d5b23ef955f1bd30c2e5396d608e46c
631e3140cbd600a3e9af8ee1871e4461fc92fb7e492226507ed2089e5ee6d411
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
77be736c11c39de3a1b021a5e66e905c76e2d32352d889d6bcc9315607c54271
ac15b6576fb3536d92d388a9a35775cfa380ad7c8b17fc8375ac403a32cc6b5e
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
304690bf13cba5d262d54d709d6f18c627880954f0140919118aea0439fbaaf3
90d0d2643fb70422ac4f8cccd1d74bda4dfe89b4b2e9d28cc5136e4d5b2969f1
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b24767627e7445ec093cc79cd6c18844e4dcdf123c6b04c24bc37f109c5cdb0f
a8639ee0478bad01370c9117b02ba791d7283e5728c982f7dc6a66e540b06781
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
0fa52a91772ceb3d45307db4f2561c132df4b966d15f7f9ce177b7a373f7163d
a3f38583f118bf8ae4c85994293b77fec599cef6a4e15509f94fb3c1cc4a69e2
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
34ea07edc731ab28748b99c398f7e1ee4d41aa22c0760d57027adad40759292f
b4629333f12d2b227c9da8411f7a11a5fe832ce15e93d7c9a33644b5d022d50f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
470a54d825e84e8ec0418a244c1fc46426c02f299f4a456ff4cc83fa604d08a0
d4914c689dacb014dcc9af6952a8620f32ed0d13e43e458de3f23d49311467f2
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
20a4f662437478b20e5a80aa30afe20b155001f94c2934843ab11b69192833d4
9547bea771af3ea663455282a1fc4f5d0ed95ea4a3c794b98106dc54744d3717
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c118a6562e0398e7f0deb64abc9913dd14acec74869d5c04c452923a81455463
d1789382c8508b18e243b7812678a2ad98187f289a818a1935bc63e771ba8d26
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
194fa719b8c96ca23f2da73d2d7225c4805b5c48af67b1efff8e76852f0a6a1c
a3980ccb70b911f218d0809985531c133861732d4ed04302896ce79c473f358f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3db661dd4d45a242b79caf642510d71841ba9f09b3b5eaa1854eabe9fcf6292e
297774561d9383cf5c364483bca25810cd5271f4e5081b53bd6d6cb06224d200
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
196769808ae37ede0a7564f42cae087a18f756b3cd31acb7d99470f1bfd70ea6
c5005462f40a2a1e384f87c6ca3d2651cc5bd1d75148dd6f16c904c15d622be7
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
dcd05de6c207f4594d347ad3dc44089204353dc898e53873f437e3db1928d629
b89751bbab2ab1f1cb27b22c36ede99dfc090d78d03bd0325aaa64b0d08deacf
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ece50a864d5a85263cb30eb39dceae90fe174336904e9208ae5c9d5da5cbb036
e45d268957df9650d2766206638a485bd44878fd5cf31f96733b23ed25e990dc
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
a2854d3c357d976b5ee1bf7b31fa541a55581102d37ec85ea719d4fdedd962cb
b110ed23919ae6c7d35c0cddb690731470280da4a2c97c6723baca0976990e2f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
dbebe5cfa79092169689d43945e4d71e1a61303ce88f6b4f02216ab69083b955
5dc1e01c268c7a755346bb9459600a5e6b605a60b0ce9cd62132dbeb6656dbb1
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
993b0f11e8cae470b0529fcfcbe9a520c855069ef63f242da3b26a3da2574d5d
7e271a84f33e4f477dbaedc723f9fbe2decdcccf67f4df418a33cfb48cb83688
+14
Переглянути файл
@@ -87,6 +87,20 @@ impl Plugin for Jobs {
host::copy_to_clipboard(arg.unwrap_or_default())?;
Ok(None)
}
"console-rules" => {
// No argument: two rules; `""` clears; anything else is one rule with that pattern.
use openidea_plugin::ConsoleRule;
let rules = match arg {
None => vec![
ConsoleRule::new(r"\[AUDIT\]").foreground("bright-yellow").style("bold").whole_line(),
ConsoleRule::new(r"job-\d+").ignore_case().foreground("cyan").background("teal"),
],
Some("") => Vec::new(),
Some(pattern) => vec![ConsoleRule::new(pattern).foreground("red")],
};
host::set_console_rules(&rules)?;
Ok(None)
}
"open-url" => {
host::open_url(arg.unwrap_or_default())?;
Ok(None)
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
d803928d82cbb2991b3f0c53b73dbe2da625b7b2ce25050706b6da09687f2873
8b1eb9f66077c8bbccb4ac39bbee1d8474846341260f4b2c4391741292ab268e
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
1c779c4913a2b83fa51980ee0017e3f2625041f1b4de921cedcdcb3bd4120d67
834b204b6417860ccc9c0dfc4ab8ee5c2fda2a57cb452d34198dbbdebc61d49c
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
bd09f3b47470087095ae50c3b0f134c471dd9ba1e5f812cd0285cef904065725
6981a004f521cab1cc8c1c53252d8790ecae15e8c736b2817b78549d34c1d8c9
+3 -3
Переглянути файл
@@ -5,9 +5,9 @@ wit_bindgen::generate!({
inline: "
package fixture:misbehave;
world misbehave {
include openidea:plugin/plugin-syntax@1.11.0;
export openidea:plugin/providers@1.11.0;
export openidea:plugin/file-actions@1.11.0;
include openidea:plugin/plugin-syntax@1.12.0;
export openidea:plugin/providers@1.12.0;
export openidea:plugin/file-actions@1.12.0;
}
",
path: "../../../../../wit",
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ada14d3aa0e462478de7dff28be356b2105f4d3ec8d4dff8a7a4a858d15c4613
6effad574d5bee69cabd68503b1f870118afbcd3260d3d49472b15b7140bfc40
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3d628f747d13d3d2fae9a75adeb951c8af09b1db5fb15523fc71289857d97d99
04b41e556a8a2984f367cddec6cd7077e6990275313c781fe58a6723b2321c8a
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
43e7552ae0f8b42383cade84924adc81952c78253186a71c2693b11d98f01acd
bd2e104a54f46eeff56945c43e71369dd0a67c4ed55b0aa8a71e5cac4c20c037
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
373188558b7925b4f9c9f975b0b6aa7b13acdf8da0c622a4ab12f39b69c1f071
d196a3cec49a5bf4909242903561aa4f74248122fa63bb1de78126c815a4a4b9
Бінарний файл не відображається.
Loaded 100 of 359 files, more files were not shown because too many files have changed in this diff. Show more