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
feat(app): support the diff command line option (#1811)
Vadim Lazukaa3323ddc51c
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex 33a9e3796..bee4317f9 100644--- a/src-tauri/src/lib.rs+++ b/src-tauri/src/lib.rs@@ -163,11 +163,19 @@ pub fn run() {builder.mount_events(app);let state = AppState::new(app.handle().clone())?;let windows = WindowsState::default();- if let Ok(cwd) = std::env::current_dir()- && let Some(path) = windows::cli_path(&std::env::args().collect::<Vec<_>>(), &cwd)- {- windows::remember_cli_position(&windows, &std::env::args().collect::<Vec<_>>(), &path);- windows.set_launch("main", windows::path_launch(path));+ if let Ok(cwd) = std::env::current_dir() {+ let args = std::env::args().collect::<Vec<_>>();+ match windows::cli_launch(&args, &cwd) {+ Some(windows::CliLaunch::Path(path)) => {+ windows::remember_cli_position(&windows, &args, &path);+ windows.set_launch("main", windows::path_launch(path));+ }+ // `openidea diff a.txt b.txt`: the main window opens the pair in the diff viewer.+ Some(windows::CliLaunch::Diff(diff)) => {+ windows.set_launch("main", windows::Launch { diff: Some(Box::new(diff)), ..Default::default() });+ }+ None => {}+ }}let menu_state = menu::MenuState::default();menu::install(app.handle(), &menu_state, &state.recent.list());diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rsindex b39c61772..6ba3b1051 100644--- a/src-tauri/src/windows.rs+++ b/src-tauri/src/windows.rs@@ -57,6 +57,9 @@ pub struct Launch {/// Comparison windows: the revisions to compare (boxed: most launches have none).#[serde(default)]pub comparison: Option<Box<ComparisonLaunch>>,+ /// `openidea diff a.txt b.txt`: the two files to open in the diff viewer (boxed: most launches have none).+ #[serde(default)]+ pub diff: Option<Box<DiffFilesLaunch>>,/// Deployment windows: the server and local selection to compare.#[serde(default)]pub deployment: Option<DeploymentLaunch>,@@ -93,6 +96,13 @@ pub struct ComparisonLaunch {pub repo: Option<ide_core::IpcPath>,}+/// The two files of a command-line diff (`openidea diff a.txt b.txt`), both sides editable.+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]+pub struct DiffFilesLaunch {+ pub left: ide_core::IpcPath,+ pub right: ide_core::IpcPath,+}+/// A caret position for a file opened from the command line: 0-based line and column.#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]#[serde(rename_all = "camelCase")]@@ -356,6 +366,9 @@ pub fn cycle_target(sorted: &[String], current: &str, forward: bool) -> Option<S/// Flags followed by a value (`--line 12`).const VALUE_FLAGS: [&str; 2] = ["--line", "--column"];+/// The subcommand opening two files side by side (`openidea diff a.txt b.txt`).+const DIFF_ARG: &str = "diff";+/// The project path from command-line arguments (`openidea /path/to/project`):/// the first argument after the binary that is not a flag or a flag's value, resolved against `cwd`.pub fn cli_path(args: &[String], cwd: &Path) -> Option<PathBuf> {@@ -374,6 +387,50 @@ pub fn cli_path(args: &[String], cwd: &Path) -> Option<PathBuf> {None}+/// What the command line asks to open (arguments after the binary, resolved against `cwd`).+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum CliLaunch {+ /// `openidea diff a.txt b.txt`: the two files side by side in the diff viewer.+ Diff(DiffFilesLaunch),+ /// A project folder or a file (`openidea /path/to/project`).+ Path(PathBuf),+}++/// What the command line asks to open; see [`CliLaunch`].+pub fn cli_launch(args: &[String], cwd: &Path) -> Option<CliLaunch> {+ if args.get(1).map(String::as_str) == Some(DIFF_ARG) {+ return match cli_diff_paths(args, cwd).as_slice() {+ [left, right, ..] => {+ Some(CliLaunch::Diff(DiffFilesLaunch { left: left.clone().into(), right: right.clone().into() }))+ }+ // One file is no pair: open it like any path.+ [one] => Some(CliLaunch::Path(one.clone())),+ // `openidea diff` with no files: like starting without arguments.+ [] => None,+ };+ }+ cli_path(args, cwd).map(CliLaunch::Path)+}++/// The file paths of a `diff` subcommand (everything after it that is not a flag or a flag's+/// value), resolved against `cwd`.+fn cli_diff_paths(args: &[String], cwd: &Path) -> Vec<PathBuf> {+ let mut paths = Vec::new();+ let mut rest = args.iter().skip(2);+ while let Some(a) = rest.next() {+ if VALUE_FLAGS.contains(&a.as_str()) {+ rest.next();+ continue;+ }+ if a.starts_with('-') || a.is_empty() {+ continue;+ }+ let p = PathBuf::from(a);+ paths.push(if p.is_absolute() { p } else { cwd.join(p) });+ }+ paths+}+/// `--line <n>` and `--column <n>` (1-based, also as `--line=<n>`) as a 0-based position;/// without `--line` there is none, without `--column` it is the line's start.pub fn cli_position(args: &[String]) -> Option<(u32, u32)> {@@ -1064,8 +1121,9 @@ pub fn on_second_instance(app: &AppHandle, args: Vec<String>, cwd: String) {return;}}- match cli_path(&args, Path::new(&cwd)) {- Some(path) => {+ match cli_launch(&args, Path::new(&cwd)) {+ Some(CliLaunch::Diff(diff)) => open_diff_files(app, diff),+ Some(CliLaunch::Path(path)) => {remember_cli_position(&app.state::<WindowsState>(), &args, &path);open_path(app, &path)}@@ -1079,6 +1137,27 @@ pub fn on_second_instance(app: &AppHandle, args: Vec<String>, cwd: String) {}}+/// `openidea diff a.txt b.txt` while the app is running: hands the pair to the window the user is+/// looking at (a project window, never an auxiliary one), else opens a new window for it.+fn open_diff_files(app: &AppHandle, diff: DiffFilesLaunch) {+ let launch = Launch { diff: Some(Box::new(diff)), ..Default::default() };+ let target = target_window(app)+ .filter(|window| auxiliary_parent(window.label()).is_none())+ .or_else(|| project_window_labels(app).into_iter().find_map(|label| app.get_webview_window(&label)));+ if let Some(window) = target {+ app.state::<WindowsState>().set_launch(window.label(), launch);+ let _ = app.emit_to(window.label(), LAUNCH_EVENT, ());+ focus(&window);+ } else {+ let app = app.clone();+ tauri::async_runtime::spawn(async move {+ if let Err(e) = create_window_for(&app, None, launch, false) {+ tracing::warn!("cannot open window: {}", e.message);+ }+ });+ }+}+pub fn cycle(app: &AppHandle, current: &str, forward: bool) {let windows = app.webview_windows();let sorted = project_window_labels(app);@@ -1480,6 +1559,39 @@ mod tests {);}+ #[test]+ fn cli_launch_parses_the_diff_subcommand() {+ let cwd = Path::new("/work");+ // Two paths: a diff pair; relative paths resolve against the cwd.+ assert_eq!(+ cli_launch(&s(&["openidea", "diff", "a.txt", "b.txt"]), cwd),+ Some(CliLaunch::Diff(DiffFilesLaunch { left: "/work/a.txt".into(), right: "/work/b.txt".into() }))+ );+ // Absolute paths stay absolute; a path with spaces is one argument (the shell unquotes it+ // before the arguments reach us).+ assert_eq!(+ cli_launch(&s(&["openidea", "diff", "/abs/my a.txt", "my b.txt"]), cwd),+ Some(CliLaunch::Diff(DiffFilesLaunch { left: "/abs/my a.txt".into(), right: "/work/my b.txt".into() }))+ );+ // Flags and their values are not file paths.+ assert_eq!(+ cli_launch(&s(&["openidea", "diff", "--line", "3", "a.txt", "b.txt"]), cwd),+ Some(CliLaunch::Diff(DiffFilesLaunch { left: "/work/a.txt".into(), right: "/work/b.txt".into() }))+ );+ // One file is no pair: it opens like any path.+ assert_eq!(+ cli_launch(&s(&["openidea", "diff", "a.txt"]), cwd),+ Some(CliLaunch::Path(PathBuf::from("/work/a.txt")))+ );+ // No files at all: like starting without arguments.+ assert_eq!(cli_launch(&s(&["openidea", "diff"]), cwd), None);+ // Only a leading `diff` is the subcommand; the rest still opens a path.+ assert_eq!(+ cli_launch(&s(&["openidea", "proj", "diff", "a.txt"]), cwd),+ Some(CliLaunch::Path(PathBuf::from("/work/proj")))+ );+ }+#[test]fn cli_position_is_one_based_on_the_command_line() {assert_eq!(cli_position(&s(&["openidea", "--line", "120", "--column", "8", "f"])), Some((119, 7)));diff --git a/src/bindings.ts b/src/bindings.tsindex 9fff26172..3feb2ea77 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -903,6 +903,8 @@ export const commands = {positions?: FilePosition[],/** Comparison windows: the revisions to compare (boxed: most launches have none). */comparison?: ComparisonLaunch | null,+ /** `openidea diff a.txt b.txt`: the two files to open in the diff viewer (boxed: most launches have none). */+ diff?: DiffFilesLaunch | null,/** Deployment windows: the server and local selection to compare. */deployment?: DeploymentLaunch | null,} | null>("window_take_launch"),@@ -3077,6 +3079,12 @@ export type Diagnostic = {server?: string | null,};+/** The two files of a command-line diff (`openidea diff a.txt b.txt`), both sides editable. */+export type DiffFilesLaunch = {+ left: IpcPath,+ right: IpcPath,+};+export type DirectoryCompareEntry = {path: string,status: DirectoryCompareStatus,@@ -4967,6 +4975,8 @@ export type Launch = {positions?: FilePosition[],/** Comparison windows: the revisions to compare (boxed: most launches have none). */comparison?: ComparisonLaunch | null,+ /** `openidea diff a.txt b.txt`: the two files to open in the diff viewer (boxed: most launches have none). */+ diff?: DiffFilesLaunch | null,/** Deployment windows: the server and local selection to compare. */deployment?: DeploymentLaunch | null,};diff --git a/src/features/app/__tests__/windows.test.ts b/src/features/app/__tests__/windows.test.tsindex 23593f9fa..b2bed6627 100644--- a/src/features/app/__tests__/windows.test.ts+++ b/src/features/app/__tests__/windows.test.ts@@ -46,6 +46,8 @@ vi.mock("@/platform/project", async (orig) => {const real = await orig<typeof import("@/platform/project")>();return { ...real, openProject: (p: string) => openProject(p) };});+const diffs: unknown[] = [];+vi.mock("@/features/vcs/diffInput", () => ({ openDiff: (data: unknown) => void diffs.push(data) }));const {openProjectInWindow,@@ -88,6 +90,7 @@ beforeEach(() => {notify.mockClear();vi.mocked(isRemoteWindow).mockReturnValue(false);opened.length = 0;+ diffs.length = 0;activePath = null;useProject.setState({ project: null, lightEdit: false, settings: null } as never);});@@ -302,6 +305,33 @@ describe("launch", () => {await consumeLaunch();expect(opened).toEqual(["/x/notes/a.txt @119:7", "/x/notes/b.txt (focus)"]);});++ it("opens the CLI diff pair in LightEdit without a project (openidea diff a b)", async () => {+ windowTakeLaunch.mockResolvedValueOnce({ project: null, files: [], diff: { left: "/x/a.txt", right: "/x/b.txt" } });+ await consumeLaunch();+ expect(lightEditOpen).toHaveBeenCalledWith("/x/b.txt");+ expect(diffs).toEqual([+ {+ path: "/x/b.txt",+ left: { type: "file", path: "/x/a.txt", label: "/x/a.txt" },+ right: { type: "worktree", label: "/x/b.txt" },+ },+ ]);+ });++ it("opens the CLI diff pair in the open project without LightEdit", async () => {+ useProject.setState(projectState("/p") as never);+ windowTakeLaunch.mockResolvedValueOnce({ project: null, files: [], diff: { left: "/p/a.txt", right: "/p/b.txt" } });+ await consumeLaunch();+ expect(lightEditOpen).not.toHaveBeenCalled();+ expect(diffs).toEqual([+ {+ path: "/p/b.txt",+ left: { type: "file", path: "/p/a.txt", label: "a.txt" },+ right: { type: "worktree", label: "b.txt" },+ },+ ]);+ });});describe("Attach", () => {diff --git a/src/features/app/windows.ts b/src/features/app/windows.tsindex 051775da9..4433deb48 100644--- a/src/features/app/windows.ts+++ b/src/features/app/windows.ts@@ -212,7 +212,7 @@ async function pickFiles(title: string): Promise<string[]> {return picked === null ? [] : Array.isArray(picked) ? picked : [picked];}-/** Takes this window's pending launch (if any) and opens its project and files. */+/** Takes this window's pending launch (if any) and opens its project, files or diff pair. */export async function consumeLaunch(): Promise<void> {if (!isTauri()) return;const launch = await commands.windowTakeLaunch().catch(() => null);@@ -221,6 +221,7 @@ export async function consumeLaunch(): Promise<void> {if (launch?.project) {if (await openHere(launch.project)) await openInEditor(files, positions);} else if (files.length) await openFilesHere(files, positions);+ else if (launch?.diff) await openCliDiff(launch.diff);else if (launch?.remote) {const { target, path } = launch.remote;await connectRemote(target, path).catch((e) =>@@ -234,6 +235,20 @@ export async function consumeLaunch(): Promise<void> {}}+/**+ * `openidea diff a.txt b.txt`: the two files side by side in the diff viewer (both editable).+ * Without a project or LightEdit session the right file opens one first, like a launched file does.+ */+async function openCliDiff(diff: { left: string; right: string }): Promise<void> {+ const s = useProject.getState();+ if (!s.project && !s.lightEdit) await openLightEdit(diff.right).catch(() => {});+ const [{ openDiff }, { compareFilesData }] = await Promise.all([+ import("@/features/vcs/diffInput"),+ import("@/features/vcs/compareData"),+ ]);+ await openDiff(compareFilesData(diff.left, diff.right));+}+/** Closes the project tabs on `side` of the `arg` tab (default: the current one), keeping that tab. */function closeProjectTabs(side: "others" | "left" | "right"): Action["run"] {return async ({ arg }) => {