Handle command line arguments and populate worktree

zed/src/lib.rs

@@ -1,6 +1,6 @@
-mod editor;
+pub mod editor;
 mod operation_queue;
-mod settings;
+pub mod settings;
 mod sum_tree;
 #[cfg(test)]
 mod test;
@@ -8,5 +8,5 @@ mod time;
 mod timer;
 mod util;
 mod watch;
-mod workspace;
+pub mod workspace;
 mod worktree;

zed/src/main.rs

@@ -3,10 +3,15 @@ use gpui::{
     executor,
     geometry::{rect::RectF, vector::vec2f},
     platform::{current as platform, App as _, Runner as _, WindowOptions},
+    FontCache,
 };
 use log::LevelFilter;
 use simplelog::SimpleLogger;
 use std::{fs, mem, rc::Rc, sync::Arc};
+use zed::{
+    editor, settings,
+    workspace::{self, OpenParams},
+};
 
 fn main() {
     init_logger();
@@ -18,23 +23,56 @@ fn main() {
             .expect("could not foreground create executor"),
     );
 
+    let font_cache = FontCache::new();
+
+    let (settings_tx, settings_rx) = settings::channel(&font_cache).unwrap();
+
+    let mut app = gpui::App::new().unwrap();
+
     platform::runner()
         .on_finish_launching(move || {
             log::info!("finish launching");
+
+            workspace::init(&mut app);
+            editor::init(&mut app);
+
             if stdout_is_a_pty() {
                 platform.activate(true);
             }
-            let window = platform
-                .open_window(
-                    WindowOptions {
-                        bounds: RectF::new(vec2f(0., 0.), vec2f(1024., 768.)),
-                        title: Some("Zed"),
-                    },
-                    foreground,
-                )
-                .expect("error opening window");
 
-            mem::forget(window); // Leak window for now so it doesn't close
+            let paths = std::env::args()
+                .skip(1)
+                .filter_map(|arg| match fs::canonicalize(arg) {
+                    Ok(path) => Some(path),
+                    Err(error) => {
+                        log::error!("error parsing path argument: {}", error);
+                        None
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            if !paths.is_empty() {
+                app.dispatch_global_action(
+                    "workspace:open_paths",
+                    OpenParams {
+                        paths,
+                        settings: settings_rx,
+                    },
+                );
+                mem::forget(app); // This is here until we hold on to the app for some reason
+            }
+
+            // let window = platform
+            //     .open_window(
+            //         WindowOptions {
+            //             bounds: RectF::new(vec2f(0., 0.), vec2f(1024., 768.)),
+            //             title: Some("Zed"),
+            //         },
+            //         foreground,
+            //     )
+            //     .expect("error opening window");
+
+            // mem::forget(window); // Leak window for now so it doesn't close
         })
         .run();
 }

zed/src/worktree/worktree.rs

@@ -5,7 +5,7 @@ use super::{
 };
 use crate::{editor::History, timer, util::post_inc};
 use anyhow::{anyhow, Result};
-use crossbeam_queue::SegQueue;
+use crossbeam_channel as channel;
 use easy_parallel::Parallel;
 use gpui::{AppContext, Entity, ModelContext, ModelHandle};
 use ignore::dir::{Ignore, IgnoreBuilder};
@@ -39,7 +39,7 @@ struct DirToScan {
     path: PathBuf,
     relative_path: PathBuf,
     ignore: Option<Ignore>,
-    dirs_to_scan: Arc<SegQueue<io::Result<DirToScan>>>,
+    dirs_to_scan: channel::Sender<io::Result<DirToScan>>,
 }
 
 impl Worktree {
@@ -61,10 +61,14 @@ impl Worktree {
 
             let tree = tree.clone();
             let (tx, rx) = smol::channel::bounded(1);
-            std::thread::spawn(move || {
-                let _ = smol::block_on(tx.send(tree.scan_dirs()));
-            });
-            let _ = ctx.spawn(async move { rx.recv().await.unwrap() }, Self::done_scanning);
+
+            ctx.background_executor()
+                .spawn(async move {
+                    tx.send(tree.scan_dirs()).await.unwrap();
+                })
+                .detach();
+
+            let _ = ctx.spawn_local(async move { rx.recv().await.unwrap() }, Self::done_scanning);
 
             let _ = ctx.spawn_stream_local(
                 timer::repeat(Duration::from_millis(100)).map(|_| ()),
@@ -95,19 +99,22 @@ impl Worktree {
         if metadata.file_type().is_dir() {
             let is_ignored = is_ignored || name == ".git";
             let id = self.push_dir(None, name, ino, is_symlink, is_ignored);
-            let queue = Arc::new(SegQueue::new());
+            let (tx, rx) = channel::unbounded();
 
-            queue.push(Ok(DirToScan {
+            let tx_ = tx.clone();
+            tx.send(Ok(DirToScan {
                 id,
                 path,
                 relative_path,
                 ignore: Some(ignore),
-                dirs_to_scan: queue.clone(),
-            }));
+                dirs_to_scan: tx_,
+            }))
+            .unwrap();
+            drop(tx);
 
             Parallel::<io::Result<()>>::new()
                 .each(0..16, |_| {
-                    while let Some(result) = queue.pop() {
+                    while let Ok(result) = rx.recv() {
                         self.scan_dir(result?)?;
                     }
                     Ok(())
@@ -150,7 +157,7 @@ impl Worktree {
                 new_children.push(id);
 
                 let dirs_to_scan = to_scan.dirs_to_scan.clone();
-                let _ = to_scan.dirs_to_scan.push(Ok(DirToScan {
+                let _ = to_scan.dirs_to_scan.send(Ok(DirToScan {
                     id,
                     path,
                     relative_path,