Merge branch 'main' into share-project

Co-Authored-By: Nathan Sobo <nathan@zed.dev>

Cargo.lock

@@ -633,17 +633,6 @@ dependencies = [
  "wyz",
 ]
 
-[[package]]
-name = "blake2b_simd"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afa748e348ad3be8263be728124b24a24f268266f6f5d58af9d75f6a40b5c587"
-dependencies = [
- "arrayref",
- "arrayvec 0.5.2",
- "constant_time_eq",
-]
-
 [[package]]
 name = "blake3"
 version = "0.3.8"
@@ -1452,6 +1441,15 @@ dependencies = [
  "dirs-sys",
 ]
 
+[[package]]
+name = "dirs"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+dependencies = [
+ "dirs-sys",
+]
+
 [[package]]
 name = "dirs-next"
 version = "2.0.0"
@@ -1464,12 +1462,12 @@ dependencies = [
 
 [[package]]
 name = "dirs-sys"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e93d7f5705de3e49895a2b5e0b8855a1c27f080192ae9c32a6432d50741a57a"
+checksum = "03d86534ed367a67548dc68113a0f5db55432fdfbb6e6f9d77704397d95d5780"
 dependencies = [
  "libc",
- "redox_users 0.3.5",
+ "redox_users",
  "winapi",
 ]
 
@@ -1480,7 +1478,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
 dependencies = [
  "libc",
- "redox_users 0.4.0",
+ "redox_users",
  "winapi",
 ]
 
@@ -2516,6 +2514,19 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "journal"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "dirs 4.0.0",
+ "editor",
+ "gpui",
+ "log",
+ "util",
+ "workspace",
+]
+
 [[package]]
 name = "jpeg-decoder"
 version = "0.1.22"
@@ -3152,7 +3163,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "instant",
  "libc",
- "redox_syscall 0.2.5",
+ "redox_syscall",
  "smallvec",
  "winapi",
 ]
@@ -3720,12 +3731,6 @@ dependencies = [
  "rand_core 0.3.1",
 ]
 
-[[package]]
-name = "redox_syscall"
-version = "0.1.57"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
-
 [[package]]
 name = "redox_syscall"
 version = "0.2.5"
@@ -3735,17 +3740,6 @@ dependencies = [
  "bitflags",
 ]
 
-[[package]]
-name = "redox_users"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"
-dependencies = [
- "getrandom 0.1.16",
- "redox_syscall 0.1.57",
- "rust-argon2",
-]
-
 [[package]]
 name = "redox_users"
 version = "0.4.0"
@@ -3753,7 +3747,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
 dependencies = [
  "getrandom 0.2.2",
- "redox_syscall 0.2.5",
+ "redox_syscall",
 ]
 
 [[package]]
@@ -3881,18 +3875,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "rust-argon2"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b18820d944b33caa75a71378964ac46f58517c92b6ae5f762636247c09e78fb"
-dependencies = [
- "base64 0.13.0",
- "blake2b_simd",
- "constant_time_eq",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "rust-embed"
 version = "6.2.0"
@@ -4545,7 +4527,7 @@ dependencies = [
  "crossbeam-channel",
  "crossbeam-queue",
  "crossbeam-utils",
- "dirs",
+ "dirs 3.0.1",
  "either",
  "futures-channel",
  "futures-core",
@@ -4850,7 +4832,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "libc",
  "rand 0.8.3",
- "redox_syscall 0.2.5",
+ "redox_syscall",
  "remove_dir_all",
  "winapi",
 ]
@@ -5673,6 +5655,7 @@ dependencies = [
  "gpui",
  "language",
  "log",
+ "parking_lot",
  "postage",
  "project",
  "serde_json",
@@ -5718,7 +5701,7 @@ dependencies = [
  "crossbeam-channel",
  "ctor",
  "diagnostics",
- "dirs",
+ "dirs 3.0.1",
  "easy-parallel",
  "editor",
  "env_logger",
@@ -5732,6 +5715,7 @@ dependencies = [
  "ignore",
  "image",
  "indexmap",
+ "journal",
  "language",
  "lazy_static",
  "libc",

crates/editor/src/editor.rs

@@ -1257,7 +1257,7 @@ impl Editor {
         }
     }
 
-    fn insert(&mut self, text: &str, cx: &mut ViewContext<Self>) {
+    pub fn insert(&mut self, text: &str, cx: &mut ViewContext<Self>) {
         self.start_transaction(cx);
         let old_selections = self.local_selections::<usize>(cx);
         let new_selections = self.buffer.update(cx, |buffer, cx| {

crates/gpui/src/app.rs

@@ -667,7 +667,7 @@ pub struct MutableAppContext {
     assets: Arc<AssetCache>,
     cx: AppContext,
     actions: HashMap<TypeId, HashMap<TypeId, Vec<Box<ActionCallback>>>>,
-    global_actions: HashMap<TypeId, Vec<Box<GlobalActionCallback>>>,
+    global_actions: HashMap<TypeId, Box<GlobalActionCallback>>,
     keystroke_matcher: keymap::Matcher,
     next_entity_id: usize,
     next_window_id: usize,
@@ -838,10 +838,13 @@ impl MutableAppContext {
             handler(action, cx);
         });
 
-        self.global_actions
+        if self
-            .entry(TypeId::of::<A>())
+            .global_actions
-            .or_default()
+            .insert(TypeId::of::<A>(), handler)
-            .push(handler);
+            .is_some()
+        {
+            panic!("registered multiple global handlers for the same action type");
+        }
     }
 
     pub fn window_ids(&self) -> impl Iterator<Item = usize> + '_ {
@@ -1125,7 +1128,7 @@ impl MutableAppContext {
             }
 
             if !halted_dispatch {
-                this.dispatch_global_action_any(action);
+                halted_dispatch = this.dispatch_global_action_any(action);
             }
             halted_dispatch
         })
@@ -1135,13 +1138,14 @@ impl MutableAppContext {
         self.dispatch_global_action_any(&action);
     }
 
-    fn dispatch_global_action_any(&mut self, action: &dyn AnyAction) {
+    fn dispatch_global_action_any(&mut self, action: &dyn AnyAction) -> bool {
         self.update(|this| {
-            if let Some((name, mut handlers)) = this.global_actions.remove_entry(&action.id()) {
+            if let Some((name, mut handler)) = this.global_actions.remove_entry(&action.id()) {
-                for handler in handlers.iter_mut().rev() {
                 handler(action, this);
-                }
+                this.global_actions.insert(name, handler);
-                this.global_actions.insert(name, handlers);
+                true
+            } else {
+                false
             }
         })
     }
@@ -3988,12 +3992,7 @@ mod tests {
 
         let actions_clone = actions.clone();
         cx.add_global_action(move |_: &Action, _: &mut MutableAppContext| {
-            actions_clone.borrow_mut().push("global a".to_string());
+            actions_clone.borrow_mut().push("global".to_string());
-        });
-
-        let actions_clone = actions.clone();
-        cx.add_global_action(move |_: &Action, _: &mut MutableAppContext| {
-            actions_clone.borrow_mut().push("global b".to_string());
         });
 
         let actions_clone = actions.clone();
@@ -4049,7 +4048,7 @@ mod tests {
 
         assert_eq!(
             *actions.borrow(),
-            vec!["4 d", "4 c", "3 b", "3 a", "2 d", "2 c", "global b", "global a"]
+            vec!["4 d", "4 c", "3 b", "3 a", "2 d", "2 c", "global"]
         );
     }
 

crates/journal/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "journal"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/journal.rs"
+
+[dependencies]
+editor = { path = "../editor" }
+gpui = { path = "../gpui" }
+util = { path = "../util" }
+workspace = { path = "../workspace" }
+chrono = "0.4"
+dirs = "4.0"
+log = "0.4"

crates/journal/src/journal.rs

@@ -0,0 +1,75 @@
+use chrono::{Datelike, Local, Timelike};
+use editor::{Autoscroll, Editor};
+use gpui::{action, keymap::Binding, MutableAppContext};
+use std::{fs::OpenOptions, sync::Arc};
+use util::TryFutureExt as _;
+use workspace::AppState;
+
+action!(NewJournalEntry);
+
+pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
+    cx.add_bindings(vec![Binding::new("ctrl-alt-cmd-j", NewJournalEntry, None)]);
+    cx.add_global_action(move |_: &NewJournalEntry, cx| new_journal_entry(app_state.clone(), cx));
+}
+
+pub fn new_journal_entry(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
+    let now = Local::now();
+    let home_dir = match dirs::home_dir() {
+        Some(home_dir) => home_dir,
+        None => {
+            log::error!("can't determine home directory");
+            return;
+        }
+    };
+
+    let journal_dir = home_dir.join("journal");
+    let month_dir = journal_dir
+        .join(format!("{:02}", now.year()))
+        .join(format!("{:02}", now.month()));
+    let entry_path = month_dir.join(format!("{:02}.md", now.day()));
+    let now = now.time();
+    let (pm, hour) = now.hour12();
+    let am_or_pm = if pm { "PM" } else { "AM" };
+    let entry_heading = format!("# {}:{:02} {}\n\n", hour, now.minute(), am_or_pm);
+
+    let create_entry = cx.background().spawn(async move {
+        std::fs::create_dir_all(month_dir)?;
+        OpenOptions::new()
+            .create(true)
+            .write(true)
+            .open(&entry_path)?;
+        Ok::<_, std::io::Error>((journal_dir, entry_path))
+    });
+
+    cx.spawn(|mut cx| {
+        async move {
+            let (journal_dir, entry_path) = create_entry.await?;
+            let workspace = cx
+                .update(|cx| workspace::open_paths(&[journal_dir], &app_state, cx))
+                .await;
+
+            let opened = workspace
+                .update(&mut cx, |workspace, cx| {
+                    workspace.open_paths(&[entry_path], cx)
+                })
+                .await;
+
+            if let Some(Some(Ok(item))) = opened.first() {
+                if let Some(editor) = item.to_any().downcast::<Editor>() {
+                    editor.update(&mut cx, |editor, cx| {
+                        let len = editor.buffer().read(cx).read(cx).len();
+                        editor.select_ranges([len..len], Some(Autoscroll::Center), cx);
+                        if len > 0 {
+                            editor.insert("\n\n", cx);
+                        }
+                        editor.insert(&entry_heading, cx);
+                    });
+                }
+            }
+
+            Ok(())
+        }
+        .log_err()
+    })
+    .detach();
+}

crates/server/src/rpc.rs

@@ -1174,7 +1174,8 @@ mod tests {
                 )
             })
             .unwrap()
-            .await;
+            .await
+            .unwrap();
         workspace_b.read_with(&cx_b, |workspace, cx| {
             let active_pane = workspace.active_pane().read(cx);
             assert!(active_pane.active_item().is_some());

crates/theme_selector/src/theme_selector.rs

@@ -11,7 +11,7 @@ use parking_lot::Mutex;
 use postage::watch;
 use std::{cmp, sync::Arc};
 use theme::ThemeRegistry;
-use workspace::{Settings, Workspace};
+use workspace::{Settings, Workspace, AppState};
 
 #[derive(Clone)]
 pub struct ThemeSelectorParams {
@@ -317,3 +317,13 @@ impl View for ThemeSelector {
         cx
     }
 }
+
+impl<'a> From<&'a AppState> for ThemeSelectorParams {
+    fn from(state: &'a AppState) -> Self {
+        Self {
+            settings_tx: state.settings_tx.clone(),
+            settings: state.settings.clone(),
+            themes: state.themes.clone(),
+        }
+    }
+}

crates/util/src/lib.rs

@@ -43,7 +43,10 @@ pub trait ResultExt {
     fn warn_on_err(self) -> Option<Self::Ok>;
 }
 
-impl<T> ResultExt for anyhow::Result<T> {
+impl<T, E> ResultExt for Result<T, E>
+where
+    E: std::fmt::Debug,
+{
     type Ok = T;
 
     fn log_err(self) -> Option<T> {

crates/workspace/Cargo.toml

@@ -17,6 +17,7 @@ project = { path = "../project" }
 theme = { path = "../theme" }
 anyhow = "1.0.38"
 log = "0.4"
+parking_lot = "0.11.1"
 postage = { version = "0.4.1", features = ["futures-traits"] }
 
 [dev-dependencies]

crates/workspace/src/pane.rs

@@ -107,15 +107,15 @@ impl Pane {
         &mut self,
         project_path: ProjectPath,
         cx: &mut ViewContext<Self>,
-    ) -> bool {
+    ) -> Option<Box<dyn ItemViewHandle>> {
         if let Some(index) = self.items.iter().position(|item| {
             item.project_path(cx.as_ref())
                 .map_or(false, |item_path| item_path == project_path)
         }) {
             self.activate_item(index, cx);
-            true
+            self.items.get(index).map(|handle| handle.boxed_clone())
         } else {
-            false
+            None
         }
     }
 

crates/workspace/src/workspace.rs

@@ -4,7 +4,7 @@ pub mod settings;
 pub mod sidebar;
 mod status_bar;
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use client::{Authenticate, ChannelList, Client, User, UserStore};
 use gpui::{
     action,
@@ -13,16 +13,18 @@ use gpui::{
     geometry::{vector::vec2f, PathBuilder},
     json::{self, to_string_pretty, ToJson},
     keymap::Binding,
-    platform::CursorStyle,
+    platform::{CursorStyle, WindowOptions},
     AnyViewHandle, AppContext, ClipboardItem, Entity, ModelContext, ModelHandle, MutableAppContext,
-    PromptLevel, RenderContext, Task, View, ViewContext, ViewHandle, WeakModelHandle,
+    PathPromptOptions, PromptLevel, RenderContext, Task, View, ViewContext, ViewHandle,
+    WeakModelHandle,
 };
 use language::LanguageRegistry;
 use log::error;
 pub use pane::*;
 pub use pane_group::*;
+use parking_lot::Mutex;
 use postage::{prelude::Stream, watch};
-use project::{Fs, Project, ProjectPath, Worktree};
+use project::{fs, Fs, Project, ProjectPath, Worktree};
 pub use settings::Settings;
 use sidebar::{Side, Sidebar, SidebarItemId, ToggleSidebarItem, ToggleSidebarItemFocus};
 use status_bar::StatusBar;
@@ -32,13 +34,23 @@ use std::{
     path::{Path, PathBuf},
     sync::Arc,
 };
-use theme::Theme;
+use theme::{Theme, ThemeRegistry};
 
-action!(OpenNew, WorkspaceParams);
+action!(Open, Arc<AppState>);
+action!(OpenNew, Arc<AppState>);
+action!(OpenPaths, OpenParams);
 action!(Save);
 action!(DebugElements);
 
 pub fn init(cx: &mut MutableAppContext) {
+    cx.add_global_action(open);
+    cx.add_global_action(move |action: &OpenPaths, cx: &mut MutableAppContext| {
+        open_paths(&action.0.paths, &action.0.app_state, cx).detach()
+    });
+    cx.add_global_action(move |action: &OpenNew, cx: &mut MutableAppContext| {
+        open_new(&action.0, cx)
+    });
+
     cx.add_action(Workspace::save_active_item);
     cx.add_action(Workspace::debug_elements);
     cx.add_action(Workspace::toggle_sidebar_item);
@@ -66,6 +78,27 @@ pub fn init(cx: &mut MutableAppContext) {
     pane::init(cx);
 }
 
+pub struct AppState {
+    pub settings_tx: Arc<Mutex<watch::Sender<Settings>>>,
+    pub settings: watch::Receiver<Settings>,
+    pub languages: Arc<LanguageRegistry>,
+    pub themes: Arc<ThemeRegistry>,
+    pub client: Arc<client::Client>,
+    pub user_store: ModelHandle<client::UserStore>,
+    pub fs: Arc<dyn fs::Fs>,
+    pub channel_list: ModelHandle<client::ChannelList>,
+    pub entry_openers: Arc<[Box<dyn EntryOpener>]>,
+    pub build_window_options: &'static dyn Fn() -> WindowOptions<'static>,
+    pub build_workspace:
+        &'static dyn Fn(&WorkspaceParams, &mut ViewContext<Workspace>) -> Workspace,
+}
+
+#[derive(Clone)]
+pub struct OpenParams {
+    pub paths: Vec<PathBuf>,
+    pub app_state: Arc<AppState>,
+}
+
 pub trait EntryOpener {
     fn open(
         &self,
@@ -468,7 +501,11 @@ impl Workspace {
         }
     }
 
-    pub fn open_paths(&mut self, abs_paths: &[PathBuf], cx: &mut ViewContext<Self>) -> Task<()> {
+    pub fn open_paths(
+        &mut self,
+        abs_paths: &[PathBuf],
+        cx: &mut ViewContext<Self>,
+    ) -> Task<Vec<Option<Result<Box<dyn ItemViewHandle>, Arc<anyhow::Error>>>>> {
         let entries = abs_paths
             .iter()
             .cloned()
@@ -484,26 +521,26 @@ impl Workspace {
                 cx.spawn(|this, mut cx| {
                     let fs = fs.clone();
                     async move {
-                        let project_path = project_path.await?;
+                        let project_path = project_path.await.ok()?;
                         if fs.is_file(&abs_path).await {
                             if let Some(entry) =
                                 this.update(&mut cx, |this, cx| this.open_entry(project_path, cx))
                             {
-                                entry.await;
+                                return Some(entry.await);
                             }
                         }
-                        Ok(())
+                        None
                     }
                 })
             })
-            .collect::<Vec<Task<Result<()>>>>();
+            .collect::<Vec<_>>();
 
         cx.foreground().spawn(async move {
+            let mut items = Vec::new();
             for task in tasks {
-                if let Err(error) = task.await {
+                items.push(task.await);
-                    log::error!("error opening paths {}", error);
-                }
             }
+            items
         })
     }
 
@@ -595,10 +632,12 @@ impl Workspace {
         &mut self,
         project_path: ProjectPath,
         cx: &mut ViewContext<Self>,
-    ) -> Option<Task<()>> {
+    ) -> Option<Task<Result<Box<dyn ItemViewHandle>, Arc<anyhow::Error>>>> {
         let pane = self.active_pane().clone();
-        if self.activate_or_open_existing_entry(project_path.clone(), &pane, cx) {
+        if let Some(existing_item) =
-            return None;
+            self.activate_or_open_existing_entry(project_path.clone(), &pane, cx)
+        {
+            return Some(cx.foreground().spawn(async move { Ok(existing_item) }));
         }
 
         let worktree = match self
@@ -629,20 +668,20 @@ impl Workspace {
         Some(cx.spawn(|this, mut cx| async move {
             let load_result = task.await;
             this.update(&mut cx, |this, cx| {
-                if let Some(pane) = pane.upgrade(&cx) {
+                let pane = pane
-                    match load_result {
+                    .upgrade(&cx)
-                        Ok(item) => {
+                    .ok_or_else(|| anyhow!("could not upgrade pane reference"))?;
+                let item = load_result?;
+
                 // By the time loading finishes, the entry could have been already added
                 // to the pane. If it was, we activate it, otherwise we'll store the
                 // item and add a new view for it.
-                            if !this.activate_or_open_existing_entry(project_path, &pane, cx) {
+                if let Some(existing) =
-                                this.add_item(item, cx);
+                    this.activate_or_open_existing_entry(project_path, &pane, cx)
-                            }
+                {
-                        }
+                    Ok(existing)
-                        Err(error) => {
+                } else {
-                            log::error!("error opening item: {}", error);
+                    Ok(this.add_item(item, cx))
-                        }
-                    }
                 }
             })
         }))
@@ -653,11 +692,13 @@ impl Workspace {
         project_path: ProjectPath,
         pane: &ViewHandle<Pane>,
         cx: &mut ViewContext<Self>,
-    ) -> bool {
+    ) -> Option<Box<dyn ItemViewHandle>> {
         // If the pane contains a view for this file, then activate
         // that item view.
-        if pane.update(cx, |pane, cx| pane.activate_entry(project_path.clone(), cx)) {
+        if let Some(existing_item_view) =
-            return true;
+            pane.update(cx, |pane, cx| pane.activate_entry(project_path.clone(), cx))
+        {
+            return Some(existing_item_view);
         }
 
         // Otherwise, if this file is already open somewhere in the workspace,
@@ -680,10 +721,10 @@ impl Workspace {
             }
         });
         if let Some(view) = view_for_existing_item {
-            pane.add_item_view(view, cx.as_mut());
+            pane.add_item_view(view.boxed_clone(), cx.as_mut());
-            true
+            Some(view)
         } else {
-            false
+            None
         }
     }
 
@@ -830,13 +871,19 @@ impl Workspace {
         pane
     }
 
-    pub fn add_item<T>(&mut self, item_handle: T, cx: &mut ViewContext<Self>)
+    pub fn add_item<T>(
+        &mut self,
+        item_handle: T,
+        cx: &mut ViewContext<Self>,
+    ) -> Box<dyn ItemViewHandle>
     where
         T: ItemHandle,
     {
         let view = item_handle.add_view(cx.window_id(), self.settings.clone(), cx);
         self.items.push(item_handle.downgrade());
-        self.active_pane().add_item_view(view, cx.as_mut());
+        self.active_pane()
+            .add_item_view(view.boxed_clone(), cx.as_mut());
+        view
     }
 
     fn activate_pane(&mut self, pane: ViewHandle<Pane>, cx: &mut ViewContext<Self>) {
@@ -1215,3 +1262,86 @@ impl Element for AvatarRibbon {
         })
     }
 }
+
+impl std::fmt::Debug for OpenParams {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("OpenParams")
+            .field("paths", &self.paths)
+            .finish()
+    }
+}
+
+impl<'a> From<&'a AppState> for WorkspaceParams {
+    fn from(state: &'a AppState) -> Self {
+        Self {
+            client: state.client.clone(),
+            fs: state.fs.clone(),
+            languages: state.languages.clone(),
+            settings: state.settings.clone(),
+            user_store: state.user_store.clone(),
+            channel_list: state.channel_list.clone(),
+            entry_openers: state.entry_openers.clone(),
+        }
+    }
+}
+
+fn open(action: &Open, cx: &mut MutableAppContext) {
+    let app_state = action.0.clone();
+    cx.prompt_for_paths(
+        PathPromptOptions {
+            files: true,
+            directories: true,
+            multiple: true,
+        },
+        move |paths, cx| {
+            if let Some(paths) = paths {
+                cx.dispatch_global_action(OpenPaths(OpenParams { paths, app_state }));
+            }
+        },
+    );
+}
+
+pub fn open_paths(
+    abs_paths: &[PathBuf],
+    app_state: &Arc<AppState>,
+    cx: &mut MutableAppContext,
+) -> Task<ViewHandle<Workspace>> {
+    log::info!("open paths {:?}", abs_paths);
+
+    // Open paths in existing workspace if possible
+    let mut existing = None;
+    for window_id in cx.window_ids().collect::<Vec<_>>() {
+        if let Some(workspace) = cx.root_view::<Workspace>(window_id) {
+            if workspace.update(cx, |view, cx| {
+                if view.contains_paths(abs_paths, cx.as_ref()) {
+                    existing = Some(workspace.clone());
+                    true
+                } else {
+                    false
+                }
+            }) {
+                break;
+            }
+        }
+    }
+
+    let workspace = existing.unwrap_or_else(|| {
+        cx.add_window((app_state.build_window_options)(), |cx| {
+            (app_state.build_workspace)(&WorkspaceParams::from(app_state.as_ref()), cx)
+        })
+        .1
+    });
+
+    let task = workspace.update(cx, |workspace, cx| workspace.open_paths(abs_paths, cx));
+    cx.spawn(|_| async move {
+        task.await;
+        workspace
+    })
+}
+
+fn open_new(app_state: &Arc<AppState>, cx: &mut MutableAppContext) {
+    let (window_id, workspace) = cx.add_window((app_state.build_window_options)(), |cx| {
+        (app_state.build_workspace)(&app_state.as_ref().into(), cx)
+    });
+    cx.dispatch_action(window_id, vec![workspace.id()], &OpenNew(app_state.clone()));
+}

crates/zed/Cargo.toml

@@ -28,24 +28,25 @@ test-support = [
 ]
 
 [dependencies]
-text = { path = "../text" }
 chat_panel = { path = "../chat_panel" }
 client = { path = "../client" }
 clock = { path = "../clock" }
+contacts_panel = { path = "../contacts_panel" }
 diagnostics = { path = "../diagnostics" }
-fsevent = { path = "../fsevent" }
-fuzzy = { path = "../fuzzy" }
 editor = { path = "../editor" }
 file_finder = { path = "../file_finder" }
+fsevent = { path = "../fsevent" }
+fuzzy = { path = "../fuzzy" }
 go_to_line = { path = "../go_to_line" }
 gpui = { path = "../gpui" }
+journal = { path = "../journal" }
 language = { path = "../language" }
 lsp = { path = "../lsp" }
-contacts_panel = { path = "../contacts_panel" }
 project = { path = "../project" }
 project_panel = { path = "../project_panel" }
 rpc = { path = "../rpc" }
 sum_tree = { path = "../sum_tree" }
+text = { path = "../text" }
 theme = { path = "../theme" }
 theme_selector = { path = "../theme_selector" }
 util = { path = "../util" }

crates/zed/src/main.rs

@@ -9,8 +9,10 @@ use parking_lot::Mutex;
 use simplelog::SimpleLogger;
 use std::{fs, path::PathBuf, sync::Arc};
 use theme::{ThemeRegistry, DEFAULT_THEME_NAME};
-use workspace::{self, settings, OpenNew, Settings};
+use workspace::{self, settings, AppState, OpenNew, OpenParams, OpenPaths, Settings};
-use zed::{self, assets::Assets, fs::RealFs, language, menus, AppState, OpenParams, OpenPaths};
+use zed::{
+    self, assets::Assets, build_window_options, build_workspace, fs::RealFs, language, menus,
+};
 
 fn main() {
     init_logger();
@@ -72,7 +74,10 @@ fn main() {
             user_store,
             fs: Arc::new(RealFs),
             entry_openers: Arc::from(entry_openers),
+            build_window_options: &build_window_options,
+            build_workspace: &build_workspace,
         });
+        journal::init(app_state.clone(), cx);
         zed::init(&app_state, cx);
         theme_selector::init(app_state.as_ref().into(), cx);
 
@@ -84,7 +89,7 @@ fn main() {
 
         let paths = collect_path_args();
         if paths.is_empty() {
-            cx.dispatch_global_action(OpenNew(app_state.as_ref().into()));
+            cx.dispatch_global_action(OpenNew(app_state.clone()));
         } else {
             cx.dispatch_global_action(OpenPaths(OpenParams { paths, app_state }));
         }

crates/zed/src/menus.rs

@@ -1,19 +1,9 @@
-use crate::{AppState, WorkspaceParams};
+use crate::AppState;
 use gpui::{Menu, MenuItem};
 use std::sync::Arc;
 
 #[cfg(target_os = "macos")]
 pub fn menus(state: &Arc<AppState>) -> Vec<Menu<'static>> {
-    let workspace_params = WorkspaceParams {
-        client: state.client.clone(),
-        fs: state.fs.clone(),
-        languages: state.languages.clone(),
-        settings: state.settings.clone(),
-        user_store: state.user_store.clone(),
-        channel_list: state.channel_list.clone(),
-        entry_openers: state.entry_openers.clone(),
-    };
-
     vec![
         Menu {
             name: "Zed",
@@ -37,13 +27,13 @@ pub fn menus(state: &Arc<AppState>) -> Vec<Menu<'static>> {
                 MenuItem::Action {
                     name: "New",
                     keystroke: Some("cmd-n"),
-                    action: Box::new(workspace::OpenNew(workspace_params)),
+                    action: Box::new(workspace::OpenNew(state.clone())),
                 },
                 MenuItem::Separator,
                 MenuItem::Action {
                     name: "Open…",
                     keystroke: Some("cmd-o"),
-                    action: Box::new(crate::Open(state.clone())),
+                    action: Box::new(workspace::Open(state.clone())),
                 },
             ],
         },

crates/zed/src/test.rs

@@ -1,4 +1,4 @@
-use crate::{assets::Assets, AppState};
+use crate::{assets::Assets, build_window_options, build_workspace, AppState};
 use client::{http::ServerResponse, test::FakeHttpClient, ChannelList, Client, UserStore};
 use gpui::{AssetSource, MutableAppContext};
 use language::LanguageRegistry;
@@ -42,6 +42,8 @@ pub fn test_app_state(cx: &mut MutableAppContext) -> Arc<AppState> {
         user_store,
         fs: Arc::new(FakeFs::new()),
         entry_openers: Arc::from(entry_openers),
+        build_window_options: &build_window_options,
+        build_workspace: &build_workspace,
     })
 }
 

crates/zed/src/zed.rs

@@ -4,7 +4,6 @@ pub mod menus;
 #[cfg(any(test, feature = "test-support"))]
 pub mod test;
 
-use self::language::LanguageRegistry;
 use chat_panel::ChatPanel;
 pub use client;
 pub use contacts_panel;
@@ -15,53 +14,23 @@ use gpui::{
     geometry::vector::vec2f,
     keymap::Binding,
     platform::{WindowBounds, WindowOptions},
-    ModelHandle, MutableAppContext, PathPromptOptions, Task, ViewContext,
+    ViewContext,
 };
 pub use lsp;
-use parking_lot::Mutex;
-use postage::watch;
 pub use project::{self, fs};
 use project_panel::ProjectPanel;
-use std::{path::PathBuf, sync::Arc};
+use std::sync::Arc;
-use theme::ThemeRegistry;
-use theme_selector::ThemeSelectorParams;
 pub use workspace;
-use workspace::{OpenNew, Settings, Workspace, WorkspaceParams};
+use workspace::{AppState, Workspace, WorkspaceParams};
 
 action!(About);
-action!(Open, Arc<AppState>);
-action!(OpenPaths, OpenParams);
 action!(Quit);
 action!(AdjustBufferFontSize, f32);
 
 const MIN_FONT_SIZE: f32 = 6.0;
 
-pub struct AppState {
-    pub settings_tx: Arc<Mutex<watch::Sender<Settings>>>,
-    pub settings: watch::Receiver<Settings>,
-    pub languages: Arc<LanguageRegistry>,
-    pub themes: Arc<ThemeRegistry>,
-    pub client: Arc<client::Client>,
-    pub user_store: ModelHandle<client::UserStore>,
-    pub fs: Arc<dyn fs::Fs>,
-    pub channel_list: ModelHandle<client::ChannelList>,
-    pub entry_openers: Arc<[Box<dyn workspace::EntryOpener>]>,
-}
-
-#[derive(Clone)]
-pub struct OpenParams {
-    pub paths: Vec<PathBuf>,
-    pub app_state: Arc<AppState>,
-}
-
 pub fn init(app_state: &Arc<AppState>, cx: &mut gpui::MutableAppContext) {
-    cx.add_global_action(open);
-    cx.add_global_action(|action: &OpenPaths, cx: &mut MutableAppContext| {
-        open_paths(action, cx).detach()
-    });
-    cx.add_global_action(open_new);
     cx.add_global_action(quit);
-
     cx.add_global_action({
         let settings_tx = app_state.settings_tx.clone();
 
@@ -79,63 +48,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut gpui::MutableAppContext) {
     ])
 }
 
-fn open(action: &Open, cx: &mut MutableAppContext) {
+pub fn build_workspace(params: &WorkspaceParams, cx: &mut ViewContext<Workspace>) -> Workspace {
-    let app_state = action.0.clone();
-    cx.prompt_for_paths(
-        PathPromptOptions {
-            files: true,
-            directories: true,
-            multiple: true,
-        },
-        move |paths, cx| {
-            if let Some(paths) = paths {
-                cx.dispatch_global_action(OpenPaths(OpenParams { paths, app_state }));
-            }
-        },
-    );
-}
-
-fn open_paths(action: &OpenPaths, cx: &mut MutableAppContext) -> Task<()> {
-    log::info!("open paths {:?}", action.0.paths);
-
-    // Open paths in existing workspace if possible
-    for window_id in cx.window_ids().collect::<Vec<_>>() {
-        if let Some(handle) = cx.root_view::<Workspace>(window_id) {
-            let task = handle.update(cx, |view, cx| {
-                if view.contains_paths(&action.0.paths, cx.as_ref()) {
-                    log::info!("open paths on existing workspace");
-                    Some(view.open_paths(&action.0.paths, cx))
-                } else {
-                    None
-                }
-            });
-
-            if let Some(task) = task {
-                return task;
-            }
-        }
-    }
-
-    log::info!("open new workspace");
-
-    // Add a new workspace if necessary
-    let app_state = &action.0.app_state;
-    let (_, workspace) = cx.add_window(window_options(), |cx| {
-        build_workspace(&WorkspaceParams::from(app_state.as_ref()), cx)
-    });
-    // cx.resize_window(window_id);
-    workspace.update(cx, |workspace, cx| {
-        workspace.open_paths(&action.0.paths, cx)
-    })
-}
-
-fn open_new(action: &OpenNew, cx: &mut MutableAppContext) {
-    let (window_id, workspace) =
-        cx.add_window(window_options(), |cx| build_workspace(&action.0, cx));
-    cx.dispatch_action(window_id, vec![workspace.id()], action);
-}
-
-fn build_workspace(params: &WorkspaceParams, cx: &mut ViewContext<Workspace>) -> Workspace {
     let mut workspace = Workspace::new(params, cx);
     let project = workspace.project().clone();
     workspace.left_sidebar_mut().add_item(
@@ -174,7 +87,7 @@ fn build_workspace(params: &WorkspaceParams, cx: &mut ViewContext<Workspace>) ->
     workspace
 }
 
-fn window_options() -> WindowOptions<'static> {
+pub fn build_window_options() -> WindowOptions<'static> {
     WindowOptions {
         bounds: WindowBounds::Maximized,
         title: None,
@@ -187,41 +100,23 @@ fn quit(_: &Quit, cx: &mut gpui::MutableAppContext) {
     cx.platform().quit();
 }
 
-impl<'a> From<&'a AppState> for WorkspaceParams {
-    fn from(state: &'a AppState) -> Self {
-        Self {
-            client: state.client.clone(),
-            fs: state.fs.clone(),
-            languages: state.languages.clone(),
-            settings: state.settings.clone(),
-            user_store: state.user_store.clone(),
-            channel_list: state.channel_list.clone(),
-            entry_openers: state.entry_openers.clone(),
-        }
-    }
-}
-
-impl<'a> From<&'a AppState> for ThemeSelectorParams {
-    fn from(state: &'a AppState) -> Self {
-        Self {
-            settings_tx: state.settings_tx.clone(),
-            settings: state.settings.clone(),
-            themes: state.themes.clone(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use editor::Editor;
+    use gpui::MutableAppContext;
     use project::ProjectPath;
     use serde_json::json;
-    use std::{collections::HashSet, path::Path};
+    use std::{
+        collections::HashSet,
+        path::{Path, PathBuf},
+    };
     use test::test_app_state;
     use theme::DEFAULT_THEME_NAME;
     use util::test::temp_tree;
-    use workspace::{pane, ItemView, ItemViewHandle, SplitDirection, WorkspaceHandle};
+    use workspace::{
+        open_paths, pane, ItemView, ItemViewHandle, OpenNew, SplitDirection, WorkspaceHandle,
+    };
 
     #[gpui::test]
     async fn test_open_paths_action(mut cx: gpui::TestAppContext) {
@@ -243,28 +138,18 @@ mod tests {
 
         cx.update(|cx| {
             open_paths(
-                &OpenPaths(OpenParams {
+                &[
-                    paths: vec![
                     dir.path().join("a").to_path_buf(),
                     dir.path().join("b").to_path_buf(),
                 ],
-                    app_state: app_state.clone(),
+                &app_state,
-                }),
                 cx,
             )
         })
         .await;
         assert_eq!(cx.window_ids().len(), 1);
 
-        cx.update(|cx| {
+        cx.update(|cx| open_paths(&[dir.path().join("a").to_path_buf()], &app_state, cx))
-            open_paths(
-                &OpenPaths(OpenParams {
-                    paths: vec![dir.path().join("a").to_path_buf()],
-                    app_state: app_state.clone(),
-                }),
-                cx,
-            )
-        })
             .await;
         assert_eq!(cx.window_ids().len(), 1);
         let workspace_1 = cx.root_view::<Workspace>(cx.window_ids()[0]).unwrap();
@@ -274,13 +159,11 @@ mod tests {
 
         cx.update(|cx| {
             open_paths(
-                &OpenPaths(OpenParams {
+                &[
-                    paths: vec![
                     dir.path().join("b").to_path_buf(),
                     dir.path().join("c").to_path_buf(),
                 ],
-                    app_state: app_state.clone(),
+                &app_state,
-                }),
                 cx,
             )
         })
@@ -291,8 +174,10 @@ mod tests {
     #[gpui::test]
     async fn test_new_empty_workspace(mut cx: gpui::TestAppContext) {
         let app_state = cx.update(test_app_state);
-        cx.update(|cx| init(&app_state, cx));
+        cx.update(|cx| {
-        cx.dispatch_global_action(workspace::OpenNew(app_state.as_ref().into()));
+            workspace::init(cx);
+        });
+        cx.dispatch_global_action(workspace::OpenNew(app_state.clone()));
         let window_id = *cx.window_ids().first().unwrap();
         let workspace = cx.root_view::<Workspace>(window_id).unwrap();
         let editor = workspace.update(&mut cx, |workspace, cx| {
@@ -357,10 +242,11 @@ mod tests {
         let file3 = entries[2].clone();
 
         // Open the first entry
-        workspace
+        let entry_1 = workspace
             .update(&mut cx, |w, cx| w.open_entry(file1.clone(), cx))
             .unwrap()
-            .await;
+            .await
+            .unwrap();
         cx.read(|cx| {
             let pane = workspace.read(cx).active_pane().read(cx);
             assert_eq!(
@@ -374,7 +260,8 @@ mod tests {
         workspace
             .update(&mut cx, |w, cx| w.open_entry(file2.clone(), cx))
             .unwrap()
-            .await;
+            .await
+            .unwrap();
         cx.read(|cx| {
             let pane = workspace.read(cx).active_pane().read(cx);
             assert_eq!(
@@ -385,9 +272,12 @@ mod tests {
         });
 
         // Open the first entry again. The existing pane item is activated.
-        workspace.update(&mut cx, |w, cx| {
+        let entry_1b = workspace
-            assert!(w.open_entry(file1.clone(), cx).is_none())
+            .update(&mut cx, |w, cx| w.open_entry(file1.clone(), cx).unwrap())
-        });
+            .await
+            .unwrap();
+        assert_eq!(entry_1.id(), entry_1b.id());
+
         cx.read(|cx| {
             let pane = workspace.read(cx).active_pane().read(cx);
             assert_eq!(
@@ -398,9 +288,15 @@ mod tests {
         });
 
         // Split the pane with the first entry, then open the second entry again.
-        workspace.update(&mut cx, |w, cx| {
+        workspace
+            .update(&mut cx, |w, cx| {
                 w.split_pane(w.active_pane().clone(), SplitDirection::Right, cx);
-            assert!(w.open_entry(file2.clone(), cx).is_none());
+                w.open_entry(file2.clone(), cx).unwrap()
+            })
+            .await
+            .unwrap();
+
+        workspace.read_with(&cx, |w, cx| {
             assert_eq!(
                 w.active_pane()
                     .read(cx)
@@ -418,8 +314,8 @@ mod tests {
                 w.open_entry(file3.clone(), cx).unwrap(),
             )
         });
-        t1.await;
+        t1.await.unwrap();
-        t2.await;
+        t2.await.unwrap();
         cx.read(|cx| {
             let pane = workspace.read(cx).active_pane().read(cx);
             assert_eq!(
@@ -576,7 +472,7 @@ mod tests {
         });
 
         // Create a new untitled buffer
-        cx.dispatch_action(window_id, vec![workspace.id()], OpenNew(params.clone()));
+        cx.dispatch_action(window_id, vec![workspace.id()], OpenNew(app_state.clone()));
         let editor = workspace.read_with(&cx, |workspace, cx| {
             workspace
                 .active_item(cx)
@@ -639,19 +535,22 @@ mod tests {
 
         // Open the same newly-created file in another pane item. The new editor should reuse
         // the same buffer.
-        cx.dispatch_action(window_id, vec![workspace.id()], OpenNew(params.clone()));
+        cx.dispatch_action(window_id, vec![workspace.id()], OpenNew(app_state.clone()));
-        workspace.update(&mut cx, |workspace, cx| {
+        workspace
+            .update(&mut cx, |workspace, cx| {
                 workspace.split_pane(workspace.active_pane().clone(), SplitDirection::Right, cx);
-            assert!(workspace
+                workspace
                     .open_entry(
                         ProjectPath {
                             worktree_id: worktree.id(),
-                        path: Path::new("the-new-name.rs").into()
+                            path: Path::new("the-new-name.rs").into(),
                         },
-                    cx
+                        cx,
                     )
-                .is_none());
+                    .unwrap()
-        });
+            })
+            .await
+            .unwrap();
         let editor2 = workspace.update(&mut cx, |workspace, cx| {
             workspace
                 .active_item(cx)
@@ -675,7 +574,7 @@ mod tests {
         let (window_id, workspace) = cx.add_window(|cx| Workspace::new(&params, cx));
 
         // Create a new untitled buffer
-        cx.dispatch_action(window_id, vec![workspace.id()], OpenNew(params.clone()));
+        cx.dispatch_action(window_id, vec![workspace.id()], OpenNew(app_state.clone()));
         let editor = workspace.read_with(&cx, |workspace, cx| {
             workspace
                 .active_item(cx)
@@ -747,7 +646,8 @@ mod tests {
         workspace
             .update(&mut cx, |w, cx| w.open_entry(file1.clone(), cx))
             .unwrap()
-            .await;
+            .await
+            .unwrap();
         cx.read(|cx| {
             assert_eq!(
                 pane_1.read(cx).active_item().unwrap().project_path(cx),