Merge pull request #2316 from zed-industries/copilot

🚨 WIP 🚨 Copilot

crates/util/src/fs.rs

@@ -0,0 +1,28 @@
+use std::path::Path;
+
+use smol::{fs, stream::StreamExt};
+
+use crate::ResultExt;
+
+// Removes all files and directories matching the given predicate
+pub async fn remove_matching<F>(dir: &Path, predicate: F)
+where
+    F: Fn(&Path) -> bool,
+{
+    if let Some(mut entries) = fs::read_dir(dir).await.log_err() {
+        while let Some(entry) = entries.next().await {
+            if let Some(entry) = entry.log_err() {
+                let entry_path = entry.path();
+                if predicate(entry_path.as_path()) {
+                    if let Ok(metadata) = fs::metadata(&entry_path).await {
+                        if metadata.is_file() {
+                            fs::remove_file(&entry_path).await.log_err();
+                        } else {
+                            fs::remove_dir_all(&entry_path).await.log_err();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

crates/util/src/github.rs

@@ -0,0 +1,46 @@
+use crate::http::HttpClient;
+use anyhow::{Context, Result};
+use futures::AsyncReadExt;
+use serde::Deserialize;
+use std::sync::Arc;
+
+pub struct GitHubLspBinaryVersion {
+    pub name: String,
+    pub url: String,
+}
+
+#[derive(Deserialize)]
+pub struct GithubRelease {
+    pub name: String,
+    pub assets: Vec<GithubReleaseAsset>,
+}
+
+#[derive(Deserialize)]
+pub struct GithubReleaseAsset {
+    pub name: String,
+    pub browser_download_url: String,
+}
+
+pub async fn latest_github_release(
+    repo_name_with_owner: &str,
+    http: Arc<dyn HttpClient>,
+) -> Result<GithubRelease, anyhow::Error> {
+    let mut response = http
+        .get(
+            &format!("https://api.github.com/repos/{repo_name_with_owner}/releases/latest"),
+            Default::default(),
+            true,
+        )
+        .await
+        .context("error fetching latest release")?;
+    let mut body = Vec::new();
+    response
+        .body_mut()
+        .read_to_end(&mut body)
+        .await
+        .context("error reading latest release")?;
+
+    let release: GithubRelease =
+        serde_json::from_slice(body.as_slice()).context("error deserializing latest release")?;
+    Ok(release)
+}

crates/util/src/http.rs

@@ -0,0 +1,117 @@
+pub use anyhow::{anyhow, Result};
+use futures::future::BoxFuture;
+use isahc::config::{Configurable, RedirectPolicy};
+pub use isahc::{
+    http::{Method, Uri},
+    Error,
+};
+pub use isahc::{AsyncBody, Request, Response};
+use smol::future::FutureExt;
+#[cfg(feature = "test-support")]
+use std::fmt;
+use std::{sync::Arc, time::Duration};
+pub use url::Url;
+
+pub trait HttpClient: Send + Sync {
+    fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>>;
+
+    fn get<'a>(
+        &'a self,
+        uri: &str,
+        body: AsyncBody,
+        follow_redirects: bool,
+    ) -> BoxFuture<'a, Result<Response<AsyncBody>, Error>> {
+        let request = isahc::Request::builder()
+            .redirect_policy(if follow_redirects {
+                RedirectPolicy::Follow
+            } else {
+                RedirectPolicy::None
+            })
+            .method(Method::GET)
+            .uri(uri)
+            .body(body);
+        match request {
+            Ok(request) => self.send(request),
+            Err(error) => async move { Err(error.into()) }.boxed(),
+        }
+    }
+
+    fn post_json<'a>(
+        &'a self,
+        uri: &str,
+        body: AsyncBody,
+    ) -> BoxFuture<'a, Result<Response<AsyncBody>, Error>> {
+        let request = isahc::Request::builder()
+            .method(Method::POST)
+            .uri(uri)
+            .header("Content-Type", "application/json")
+            .body(body);
+        match request {
+            Ok(request) => self.send(request),
+            Err(error) => async move { Err(error.into()) }.boxed(),
+        }
+    }
+}
+
+pub fn client() -> Arc<dyn HttpClient> {
+    Arc::new(
+        isahc::HttpClient::builder()
+            .connect_timeout(Duration::from_secs(5))
+            .low_speed_timeout(100, Duration::from_secs(5))
+            .build()
+            .unwrap(),
+    )
+}
+
+impl HttpClient for isahc::HttpClient {
+    fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>> {
+        Box::pin(async move { self.send_async(req).await })
+    }
+}
+
+#[cfg(feature = "test-support")]
+pub struct FakeHttpClient {
+    handler: Box<
+        dyn 'static
+            + Send
+            + Sync
+            + Fn(Request<AsyncBody>) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>>,
+    >,
+}
+
+#[cfg(feature = "test-support")]
+impl FakeHttpClient {
+    pub fn create<Fut, F>(handler: F) -> Arc<dyn HttpClient>
+    where
+        Fut: 'static + Send + futures::Future<Output = Result<Response<AsyncBody>, Error>>,
+        F: 'static + Send + Sync + Fn(Request<AsyncBody>) -> Fut,
+    {
+        Arc::new(Self {
+            handler: Box::new(move |req| Box::pin(handler(req))),
+        })
+    }
+
+    pub fn with_404_response() -> Arc<dyn HttpClient> {
+        Self::create(|_| async move {
+            Ok(Response::builder()
+                .status(404)
+                .body(Default::default())
+                .unwrap())
+        })
+    }
+}
+
+#[cfg(feature = "test-support")]
+impl fmt::Debug for FakeHttpClient {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FakeHttpClient").finish()
+    }
+}
+
+#[cfg(feature = "test-support")]
+impl HttpClient for FakeHttpClient {
+    fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>> {
+        let future = (self.handler)(req);
+        Box::pin(async move { future.await.map(Into::into) })
+    }
+}

crates/util/src/paths.rs

@@ -6,6 +6,7 @@ lazy_static::lazy_static! {
     pub static ref LOGS_DIR: PathBuf = HOME.join("Library/Logs/Zed");
     pub static ref SUPPORT_DIR: PathBuf = HOME.join("Library/Application Support/Zed");
     pub static ref LANGUAGES_DIR: PathBuf = HOME.join("Library/Application Support/Zed/languages");
+    pub static ref COPILOT_DIR: PathBuf = HOME.join("Library/Application Support/Zed/copilot");
     pub static ref DB_DIR: PathBuf = HOME.join("Library/Application Support/Zed/db");
     pub static ref SETTINGS: PathBuf = CONFIG_DIR.join("settings.json");
     pub static ref KEYMAP: PathBuf = CONFIG_DIR.join("keymap.json");

crates/util/src/util.rs

@@ -1,4 +1,7 @@
 pub mod channel;
+pub mod fs;
+pub mod github;
+pub mod http;
 pub mod paths;
 #[cfg(any(test, feature = "test-support"))]
 pub mod test;
@@ -298,6 +301,7 @@ pub trait RangeExt<T> {
     fn sorted(&self) -> Self;
     fn to_inclusive(&self) -> RangeInclusive<T>;
     fn overlaps(&self, other: &Range<T>) -> bool;
+    fn contains_inclusive(&self, other: &Range<T>) -> bool;
 }
 
 impl<T: Ord + Clone> RangeExt<T> for Range<T> {
@@ -312,6 +316,10 @@ impl<T: Ord + Clone> RangeExt<T> for Range<T> {
     fn overlaps(&self, other: &Range<T>) -> bool {
         self.start < other.end && other.start < self.end
     }
+
+    fn contains_inclusive(&self, other: &Range<T>) -> bool {
+        self.start <= other.start && other.end <= self.end
+    }
 }
 
 impl<T: Ord + Clone> RangeExt<T> for RangeInclusive<T> {
@@ -326,6 +334,10 @@ impl<T: Ord + Clone> RangeExt<T> for RangeInclusive<T> {
     fn overlaps(&self, other: &Range<T>) -> bool {
         self.start() < &other.end && &other.start <= self.end()
     }
+
+    fn contains_inclusive(&self, other: &Range<T>) -> bool {
+        self.start() <= &other.start && &other.end <= self.end()
+    }
 }
 
 #[cfg(test)]