The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
//! IPC commands of `ide_host::ops::vcs` (the shared implementation).
use crate::state::AppState;
use ide_core::{IdeResult, RequestId};
#[allow(unused_imports)]
pub use ide_host::ops::vcs::*;
use ide_vcs::*;
use std::path::PathBuf;
use tauri::ipc::Channel;
use tauri::{State, Window};
/// Changes of every repository of the project.
#[tauri::command]
#[specta::specta]
pub async fn vcs_status(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<FileStatus>> {
ide_host::ops::vcs::status(&state.host, window.label()).await
}
/// The project's repositories, the primary one first.
#[tauri::command]
#[specta::specta]
pub fn vcs_roots(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<VcsRoot>> {
ide_host::ops::vcs::vcs_roots(&state.host, window.label())
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_branch_info(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
) -> IdeResult<BranchInfo> {
ide_host::ops::vcs::vcs_branch_info(&state.host, window.label(), repo).await
}
/// Gutter change markers for a file, computed against its current (unsaved) text.
#[tauri::command]
#[specta::specta]
pub async fn vcs_line_hunks(window: Window, state: State<'_, AppState>, path: PathBuf) -> IdeResult<Vec<LineHunk>> {
ide_host::ops::vcs::vcs_line_hunks(&state.host, window.label(), path).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_file_at(
window: Window,
state: State<'_, AppState>,
path: PathBuf,
rev: Option<String>,
) -> IdeResult<Option<String>> {
ide_host::ops::vcs::vcs_file_at(&state.host, window.label(), path, rev).await
}
/// History for Selection: commits that changed `lines` (0-based, inclusive) of `path`'s
/// editor text. Cancellable with `cancel_request(request)`.
#[tauri::command]
#[specta::specta]
pub async fn vcs_block_history(
window: Window,
state: State<'_, AppState>,
request: RequestId,
path: PathBuf,
text: Option<String>,
lines: (u32, u32),
) -> IdeResult<BlockHistory> {
ide_host::ops::vcs::vcs_block_history(&state.host, window.label(), request, path, text, lines).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_blame(
window: Window,
state: State<'_, AppState>,
path: PathBuf,
text: Option<String>,
revision: Option<String>,
) -> IdeResult<Vec<BlameLine>> {
ide_host::ops::vcs::vcs_blame(&state.host, window.label(), path, text, revision).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_log(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
query: LogQuery,
) -> IdeResult<Vec<Commit>> {
ide_host::ops::vcs::vcs_log(&state.host, window.label(), repo, query).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_log_refs(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
) -> IdeResult<std::collections::BTreeMap<String, String>> {
ide_host::ops::vcs::vcs_log_refs(&state.host, window.label(), repo).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_log_users(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
) -> IdeResult<Vec<String>> {
ide_host::ops::vcs::vcs_log_users(&state.host, window.label(), repo).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_open_external_log(
window: Window,
state: State<'_, AppState>,
path: PathBuf,
) -> IdeResult<ide_core::IpcPath> {
ide_host::ops::vcs::vcs_open_external_log(&state.host, window.label(), path).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_log_details(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
revision: String,
) -> IdeResult<LogDetails> {
ide_host::ops::vcs::vcs_log_details(&state.host, window.label(), repo, revision).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_log_details_batch(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
revisions: Vec<String>,
request: RequestId,
) -> IdeResult<Vec<LogDetails>> {
ide_host::ops::vcs::vcs_log_details_batch(&state.host, window.label(), repo, revisions, request).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_revision_children(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
revision: String,
directory: String,
) -> IdeResult<Vec<String>> {
ide_host::ops::vcs::vcs_revision_children(&state.host, window.label(), repo, revision, directory).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_revision_files(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
revision: String,
) -> IdeResult<Vec<String>> {
ide_host::ops::vcs::vcs_revision_files(&state.host, window.label(), repo, revision).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_commit_files(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
commit: String,
) -> IdeResult<Vec<ChangedFile>> {
ide_host::ops::vcs::vcs_commit_files(&state.host, window.label(), repo, commit).await
}
/// Combined changes of several commits, `commits` oldest first.
#[tauri::command]
#[specta::specta]
pub async fn vcs_commits_changes(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
commits: Vec<String>,
) -> IdeResult<Vec<RevisionChange>> {
ide_host::ops::vcs::vcs_commits_changes(&state.host, window.label(), repo, commits).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_branches(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<Branch>> {
ide_host::ops::vcs::vcs_branches(&state.host, window.label(), repo).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_stashes(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<Stash>> {
ide_host::ops::vcs::vcs_stashes(&state.host, window.label(), repo).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_stage(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {
ide_host::ops::vcs::vcs_stage(&state.host, window.label(), paths).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_add_to_ignore(
window: Window,
state: State<'_, AppState>,
paths: Vec<PathBuf>,
destination: IgnoreDestination,
) -> IdeResult<Vec<ide_core::IpcPath>> {
ide_host::ops::vcs::vcs_add_to_ignore(&state.host, window.label(), paths, destination).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_unstage(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {
ide_host::ops::vcs::vcs_unstage(&state.host, window.label(), paths).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_stage_patch(window: Window, state: State<'_, AppState>, patch: String) -> IdeResult<()> {
ide_host::ops::vcs::vcs_stage_patch(&state.host, window.label(), patch).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_discard(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {
ide_host::ops::vcs::vcs_discard(&state.host, window.label(), paths).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_commit(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
message: String,
options: CommitOptions,
) -> IdeResult<String> {
ide_host::ops::vcs::vcs_commit(&state.host, window.label(), repo, message, options).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_checkout(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
branch: String,
create: bool,
options: Option<ide_vcs::CheckoutOptions>,
) -> IdeResult<ide_vcs::CheckoutOutcome> {
ide_host::ops::vcs::vcs_checkout(&state.host, window.label(), repo, branch, create, options).await
}
/// New Branch: creates `name` at `start` (HEAD when absent), optionally checking it out.
#[tauri::command]
#[specta::specta]
pub async fn vcs_create_branch(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
name: String,
start: Option<String>,
checkout: bool,
overwrite: Option<bool>,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_create_branch(&state.host, window.label(), repo, name, start, checkout, overwrite).await
}
/// Undo Commit: moves HEAD back to the commit's parent, keeping its changes staged.
/// Returns the undone commit's message.
#[tauri::command]
#[specta::specta]
pub async fn vcs_undo_commit(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
commit: String,
) -> IdeResult<String> {
ide_host::ops::vcs::vcs_undo_commit(&state.host, window.label(), repo, commit).await
}
/// Edit Commit Message: rewrites the commit and its descendants without touching the
/// working tree.
#[tauri::command]
#[specta::specta]
pub async fn vcs_reword(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
commit: String,
message: String,
) -> IdeResult<ide_vcs::HeadChange> {
ide_host::ops::vcs::vcs_reword(&state.host, window.label(), repo, commit, message).await
}
/// Undo of a history rewrite (Edit Commit Message, Drop, Squash).
#[tauri::command]
#[specta::specta]
pub async fn vcs_restore_head(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
before: String,
after: String,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_restore_head(&state.host, window.label(), repo, before, after).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_delete_branch(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
branch: String,
) -> IdeResult<ide_vcs::DeletedBranch> {
ide_host::ops::vcs::vcs_delete_branch(&state.host, window.label(), repo, branch).await
}
/// Tag › Delete: the result is what "Restore" needs.
#[tauri::command]
#[specta::specta]
pub async fn vcs_delete_tag(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
name: String,
) -> IdeResult<ide_vcs::DeletedTag> {
ide_host::ops::vcs::vcs_delete_tag(&state.host, window.label(), repo, name).await
}
/// "Restore" of the tag-deleted notification.
#[tauri::command]
#[specta::specta]
pub async fn vcs_restore_tag(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
deleted: ide_vcs::DeletedTag,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_restore_tag(&state.host, window.label(), repo, deleted).await
}
/// "Restore" of the branch-deleted notification.
#[tauri::command]
#[specta::specta]
pub async fn vcs_restore_branch(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
deleted: ide_vcs::DeletedBranch,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_restore_branch(&state.host, window.label(), repo, deleted).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_rename_branch(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
from: String,
to: String,
unset_upstream: bool,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_rename_branch(&state.host, window.label(), repo, from, to, unset_upstream).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_merge(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
branch: String,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_merge(&state.host, window.label(), repo, branch).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_rebase(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
onto: String,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_rebase(&state.host, window.label(), repo, onto).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_stash_push(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
message: Option<String>,
include_untracked: bool,
keep_index: bool,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_stash_push(&state.host, window.label(), repo, message, include_untracked, keep_index).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_stash_apply(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
index: u32,
pop: bool,
reinstate_index: bool,
branch: Option<String>,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_stash_apply(&state.host, window.label(), repo, index, pop, reinstate_index, branch).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_stash_drop(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
index: u32,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_stash_drop(&state.host, window.label(), repo, index).await
}
/// Network operation; progress lines stream through `on_output`. Cancellable.
#[tauri::command]
#[specta::specta]
pub async fn vcs_remote(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
request: RequestId,
op: RemoteOp,
on_output: Channel<String>,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_remote(&state.host, window.label(), repo, request, op, crate::commands::sender(on_output))
.await
}
/// The user's side is `ours` (sides swapped during a rebase, as in IDEA).
#[tauri::command]
#[specta::specta]
pub async fn vcs_conflict_versions(
window: Window,
state: State<'_, AppState>,
path: PathBuf,
) -> IdeResult<ide_vcs::MergeVersions> {
ide_host::ops::vcs::vcs_conflict_versions(&state.host, window.label(), path).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_diff_text(
window: Window,
state: State<'_, AppState>,
path: PathBuf,
staged: bool,
) -> IdeResult<String> {
ide_host::ops::vcs::vcs_diff_text(&state.host, window.label(), path, staged).await
}
/// Line hunks between two arbitrary texts (diff viewer, commit dialog).
#[tauri::command]
#[specta::specta]
pub fn vcs_diff_hunks(state: State<'_, AppState>, old_text: String, new_text: String) -> Vec<LineHunk> {
ide_host::ops::vcs::vcs_diff_hunks(&state.host, "", old_text, new_text)
}
/// Stages only the selected hunks of a file's working-tree changes.
/// Indices refer to `vcs_diff_hunks(index_text, worktree_text)`.
#[tauri::command]
#[specta::specta]
pub async fn vcs_stage_hunks(
window: Window,
state: State<'_, AppState>,
path: PathBuf,
hunks: Vec<u32>,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_stage_hunks(&state.host, window.label(), path, hunks).await
}
/// Clones a repository (Get from VCS). Works without an open project.
#[tauri::command]
#[specta::specta]
pub async fn vcs_clone(
state: State<'_, AppState>,
request: RequestId,
url: String,
dest: PathBuf,
depth: Option<u32>,
on_output: Channel<String>,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_clone(&state.host, "", request, url, dest, depth, crate::commands::sender(on_output)).await
}
/// `git init` in `dir` (File › New Project… "Create Git repository").
#[tauri::command]
#[specta::specta]
pub async fn vcs_init(state: State<'_, AppState>, dir: PathBuf) -> IdeResult<()> {
ide_host::ops::vcs::vcs_init(&state.host, "", dir).await
}
/// Settings › Git › Test: runs `git --version` on `path`, or on the auto-detected
/// executable when `path` is empty.
#[tauri::command]
#[specta::specta]
pub async fn vcs_git_version(window: Window, state: State<'_, AppState>, path: String) -> IdeResult<GitExecutableInfo> {
ide_host::ops::vcs::vcs_git_version(&state.host, window.label(), path).await
}
/// The auto-detected git executable (shown as the field's placeholder).
#[tauri::command]
#[specta::specta]
pub fn vcs_detected_git(state: State<'_, AppState>) -> Option<String> {
ide_host::ops::vcs::vcs_detected_git(&state.host, "")
}
/// `git config --get <key>` in the project repository; `None` when unset.
#[tauri::command]
#[specta::specta]
pub async fn vcs_config_get(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
key: String,
) -> IdeResult<Option<String>> {
ide_host::ops::vcs::vcs_config_get(&state.host, window.label(), repo, key).await
}
/// Local history operation that may take a while (hooks, large checkouts); git's
/// output streams through `on_output`. Cancellable.
#[tauri::command]
#[specta::specta]
pub async fn vcs_operation(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
request: RequestId,
op: GitOperation,
on_output: Channel<String>,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_operation(
&state.host,
window.label(),
repo,
request,
op,
crate::commands::sender(on_output),
)
.await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_create_tag(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
name: String,
commit: String,
message: Option<String>,
force: bool,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_create_tag(&state.host, window.label(), repo, name, commit, message, force).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_tags(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<String>> {
ide_host::ops::vcs::vcs_tags(&state.host, window.label(), repo).await
}
/// Merge dialog: merges `branches` into the current branch.
#[tauri::command]
#[specta::specta]
pub async fn vcs_merge_with(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
branches: Vec<String>,
options: MergeOptions,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_merge_with(&state.host, window.label(), repo, branches, options).await
}
/// Rebase dialog: rebases the current branch onto `upstream` (or `--onto`).
#[tauri::command]
#[specta::specta]
pub async fn vcs_rebase_with(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
upstream: String,
options: RebaseOptions,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_rebase_with(&state.host, window.label(), repo, upstream, options).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_remotes(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<Remote>> {
ide_host::ops::vcs::vcs_remotes(&state.host, window.label(), repo).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_edit_remote(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
edit: RemoteEdit,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_edit_remote(&state.host, window.label(), repo, edit).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_worktrees(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
) -> IdeResult<Vec<Worktree>> {
ide_host::ops::vcs::vcs_worktrees(&state.host, window.label(), repo).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_add_worktree(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
path: PathBuf,
commitish: String,
new_branch: Option<String>,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_add_worktree(&state.host, window.label(), repo, path, commitish, new_branch).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_remove_worktree(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
path: PathBuf,
force: bool,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_remove_worktree(&state.host, window.label(), repo, path, force).await
}
/// Compare with Local: tracked files that differ between `rev` and the working tree.
#[tauri::command]
#[specta::specta]
pub async fn vcs_diff_with_worktree(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
rev: String,
) -> IdeResult<Vec<ChangedFile>> {
ide_host::ops::vcs::vcs_diff_with_worktree(&state.host, window.label(), repo, rev).await
}
/// Files that differ between two revisions (the "N files updated" of Update Project).
#[tauri::command]
#[specta::specta]
pub async fn vcs_diff_revisions(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
from: String,
to: String,
) -> IdeResult<Vec<ChangedFile>> {
ide_host::ops::vcs::vcs_diff_revisions(&state.host, window.label(), repo, from, to).await
}
/// Added and deleted lines between two revisions (Git Log › lines added and deleted).
/// `paths` limits the diff to those repository-relative paths; empty diffs every file.
#[tauri::command]
#[specta::specta]
pub async fn vcs_diff_numstat(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
from: String,
to: String,
paths: Vec<String>,
) -> IdeResult<Vec<FileLineStats>> {
ide_host::ops::vcs::vcs_diff_numstat(&state.host, window.label(), repo, from, to, paths).await
}
/// Whether the repository has the executable Git hook `name` (Push dialog › Run Git hooks).
#[tauri::command]
#[specta::specta]
pub async fn vcs_has_hook(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
name: String,
) -> IdeResult<bool> {
ide_host::ops::vcs::vcs_has_hook(&state.host, window.label(), repo, name).await
}
/// The best common ancestor of `a` and `b` (`git merge-base`), if any.
#[tauri::command]
#[specta::specta]
pub async fn vcs_merge_base(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
a: String,
b: String,
) -> IdeResult<Option<String>> {
ide_host::ops::vcs::vcs_merge_base(&state.host, window.label(), repo, a, b).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_create_patch(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
source: PatchSource,
) -> IdeResult<String> {
ide_host::ops::vcs::vcs_create_patch(&state.host, window.label(), repo, source).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_patch_preview(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
patch: String,
) -> IdeResult<Vec<PatchFile>> {
ide_host::ops::vcs::vcs_patch_preview(&state.host, window.label(), repo, patch).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_apply_patch(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
patch: String,
) -> IdeResult<ApplyOutcome> {
ide_host::ops::vcs::vcs_apply_patch(&state.host, window.label(), repo, patch).await
}
/// Shelve Changes: saves the changes of `paths` as a patch on the shelf and reverts them.
#[tauri::command]
#[specta::specta]
pub async fn vcs_shelve(
window: Window,
state: State<'_, AppState>,
name: String,
paths: Vec<PathBuf>,
) -> IdeResult<ShelvedChangeList> {
ide_host::ops::vcs::vcs_shelve(&state.host, window.label(), name, paths).await
}
#[tauri::command]
#[specta::specta]
pub fn vcs_shelves(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<ShelvedChangeList>> {
ide_host::ops::vcs::vcs_shelves(&state.host, window.label())
}
/// Unshelve: applies the shelved patch (3-way merging; conflicts are left for the
/// merge UI); with `remove`, deletes it from the shelf.
#[tauri::command]
#[specta::specta]
pub async fn vcs_unshelve(
window: Window,
state: State<'_, AppState>,
id: String,
remove: bool,
path: Option<String>,
) -> IdeResult<ApplyOutcome> {
ide_host::ops::vcs::vcs_unshelve(&state.host, window.label(), id, remove, path).await
}
#[tauri::command]
#[specta::specta]
pub fn vcs_shelf_delete(window: Window, state: State<'_, AppState>, id: String, path: Option<String>) -> IdeResult<()> {
ide_host::ops::vcs::vcs_shelf_delete(&state.host, window.label(), id, path)
}
#[tauri::command]
#[specta::specta]
pub fn vcs_shelf_rename(window: Window, state: State<'_, AppState>, id: String, name: String) -> IdeResult<()> {
ide_host::ops::vcs::vcs_shelf_rename(&state.host, window.label(), id, name)
}
#[tauri::command]
#[specta::specta]
pub fn vcs_shelf_patch(
window: Window,
state: State<'_, AppState>,
id: String,
path: Option<String>,
) -> IdeResult<String> {
ide_host::ops::vcs::vcs_shelf_patch(&state.host, window.label(), id, path)
}
#[tauri::command]
#[specta::specta]
pub fn vcs_changelists_load(window: Window, state: State<'_, AppState>) -> IdeResult<ChangelistState> {
ide_host::ops::vcs::vcs_changelists_load(&state.host, window.label())
}
#[tauri::command]
#[specta::specta]
pub fn vcs_changelists_save(window: Window, state: State<'_, AppState>, changelists: ChangelistState) -> IdeResult<()> {
ide_host::ops::vcs::vcs_changelists_save(&state.host, window.label(), changelists)
}
/// Create Patch › Save to file.
#[tauri::command]
#[specta::specta]
pub async fn vcs_write_patch(
window: Window,
state: State<'_, AppState>,
path: PathBuf,
patch: String,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_write_patch(&state.host, window.label(), path, patch).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_shelf_diff(
window: Window,
state: State<'_, AppState>,
id: String,
) -> IdeResult<Vec<ide_vcs::shelf::ShelfDiffFile>> {
ide_host::ops::vcs::vcs_shelf_diff(&state.host, window.label(), id).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_shelf_import(
window: Window,
state: State<'_, AppState>,
repo: Option<PathBuf>,
name: String,
patch: String,
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_shelf_import(&state.host, window.label(), repo, name, patch).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_compare_scope(
window: Window,
state: State<'_, AppState>,
paths: Vec<PathBuf>,
) -> IdeResult<ide_vcs::CompareScope> {
ide_host::ops::vcs::vcs_compare_scope(&state.host, window.label(), paths).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_compare_paths(
window: Window,
state: State<'_, AppState>,
paths: Vec<PathBuf>,
revision: String,
repositories: Option<Vec<PathBuf>>,
request: RequestId,
) -> IdeResult<ide_vcs::CompareResult> {
ide_host::ops::vcs::vcs_compare_paths(&state.host, window.label(), paths, revision, repositories, request).await
}