Add a registry for GitHostingProviders (#11470)

This PR adds a registry for `GitHostingProvider`s.

The intent here is to help decouple these provider-specific concerns
from the lower-level `git` crate.

Similar to languages, the Git hosting providers live in the new
`git_hosting_providers` crate.

This work also lays the foundation for if we wanted to allow defining a
`GitHostingProvider` from within an extension. This could be useful if
we wanted to extend the support to work with self-hosted Git providers
(like GitHub Enterprise).

I also took the opportunity to move some of the provider-specific code
out of the `util` crate, since it had leaked into there.

Release Notes:

- N/A

crates/git_hosting_providers/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "git_hosting_providers"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/git_hosting_providers.rs"
+
+[dependencies]
+anyhow.workspace = true
+async-trait.workspace = true
+futures.workspace = true
+git.workspace = true
+gpui.workspace = true
+isahc.workspace = true
+regex.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+url.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+unindent.workspace = true
+serde_json.workspace = true
+pretty_assertions.workspace = true

crates/git_hosting_providers/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/git_hosting_providers/src/git_hosting_providers.rs

@@ -0,0 +1,26 @@
+mod providers;
+
+use std::sync::Arc;
+
+use git::GitHostingProviderRegistry;
+use gpui::AppContext;
+
+pub use crate::providers::*;
+
+/// Initializes the Git hosting providers.
+pub fn init(cx: &mut AppContext) {
+    let provider_registry = GitHostingProviderRegistry::global(cx);
+
+    // The providers are stored in a `BTreeMap`, so insertion order matters.
+    // GitHub comes first.
+    provider_registry.register_hosting_provider(Arc::new(Github));
+
+    // Then GitLab.
+    provider_registry.register_hosting_provider(Arc::new(Gitlab));
+
+    // Then the other providers, in the order they were added.
+    provider_registry.register_hosting_provider(Arc::new(Gitee));
+    provider_registry.register_hosting_provider(Arc::new(Bitbucket));
+    provider_registry.register_hosting_provider(Arc::new(Sourcehut));
+    provider_registry.register_hosting_provider(Arc::new(Codeberg));
+}

crates/git_hosting_providers/src/providers.rs

@@ -0,0 +1,13 @@
+mod bitbucket;
+mod codeberg;
+mod gitee;
+mod github;
+mod gitlab;
+mod sourcehut;
+
+pub use bitbucket::*;
+pub use codeberg::*;
+pub use gitee::*;
+pub use github::*;
+pub use gitlab::*;
+pub use sourcehut::*;

crates/git_hosting_providers/src/providers/bitbucket.rs

@@ -0,0 +1,175 @@
+use url::Url;
+
+use git::{BuildCommitPermalinkParams, BuildPermalinkParams, GitHostingProvider, ParsedGitRemote};
+
+pub struct Bitbucket;
+
+impl GitHostingProvider for Bitbucket {
+    fn name(&self) -> String {
+        "Bitbucket".to_string()
+    }
+
+    fn base_url(&self) -> Url {
+        Url::parse("https://bitbucket.org").unwrap()
+    }
+
+    fn supports_avatars(&self) -> bool {
+        false
+    }
+
+    fn format_line_number(&self, line: u32) -> String {
+        format!("lines-{line}")
+    }
+
+    fn format_line_numbers(&self, start_line: u32, end_line: u32) -> String {
+        format!("lines-{start_line}:{end_line}")
+    }
+
+    fn parse_remote_url<'a>(&self, url: &'a str) -> Option<ParsedGitRemote<'a>> {
+        if url.contains("bitbucket.org") {
+            let (_, repo_with_owner) = url.trim_end_matches(".git").split_once("bitbucket.org")?;
+            let (owner, repo) = repo_with_owner
+                .trim_start_matches('/')
+                .trim_start_matches(':')
+                .split_once('/')?;
+
+            return Some(ParsedGitRemote { owner, repo });
+        }
+
+        None
+    }
+
+    fn build_commit_permalink(
+        &self,
+        remote: &ParsedGitRemote,
+        params: BuildCommitPermalinkParams,
+    ) -> Url {
+        let BuildCommitPermalinkParams { sha } = params;
+        let ParsedGitRemote { owner, repo } = remote;
+
+        self.base_url()
+            .join(&format!("{owner}/{repo}/commits/{sha}"))
+            .unwrap()
+    }
+
+    fn build_permalink(&self, remote: ParsedGitRemote, params: BuildPermalinkParams) -> Url {
+        let ParsedGitRemote { owner, repo } = remote;
+        let BuildPermalinkParams {
+            sha,
+            path,
+            selection,
+        } = params;
+
+        let mut permalink = self
+            .base_url()
+            .join(&format!("{owner}/{repo}/src/{sha}/{path}"))
+            .unwrap();
+        permalink.set_fragment(
+            selection
+                .map(|selection| self.line_fragment(&selection))
+                .as_deref(),
+        );
+        permalink
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use git::{parse_git_remote_url, GitHostingProviderRegistry};
+
+    use super::*;
+
+    #[test]
+    fn test_parse_git_remote_url_bitbucket_https_with_username() {
+        let provider_registry = Arc::new(GitHostingProviderRegistry::new());
+        provider_registry.register_hosting_provider(Arc::new(Bitbucket));
+        let url = "https://thorstenballzed@bitbucket.org/thorstenzed/testingrepo.git";
+        let (provider, parsed) = parse_git_remote_url(provider_registry, url).unwrap();
+        assert_eq!(provider.name(), "Bitbucket");
+        assert_eq!(parsed.owner, "thorstenzed");
+        assert_eq!(parsed.repo, "testingrepo");
+    }
+
+    #[test]
+    fn test_parse_git_remote_url_bitbucket_https_without_username() {
+        let provider_registry = Arc::new(GitHostingProviderRegistry::new());
+        provider_registry.register_hosting_provider(Arc::new(Bitbucket));
+        let url = "https://bitbucket.org/thorstenzed/testingrepo.git";
+        let (provider, parsed) = parse_git_remote_url(provider_registry, url).unwrap();
+        assert_eq!(provider.name(), "Bitbucket");
+        assert_eq!(parsed.owner, "thorstenzed");
+        assert_eq!(parsed.repo, "testingrepo");
+    }
+
+    #[test]
+    fn test_parse_git_remote_url_bitbucket_git() {
+        let provider_registry = Arc::new(GitHostingProviderRegistry::new());
+        provider_registry.register_hosting_provider(Arc::new(Bitbucket));
+        let url = "git@bitbucket.org:thorstenzed/testingrepo.git";
+        let (provider, parsed) = parse_git_remote_url(provider_registry, url).unwrap();
+        assert_eq!(provider.name(), "Bitbucket");
+        assert_eq!(parsed.owner, "thorstenzed");
+        assert_eq!(parsed.repo, "testingrepo");
+    }
+
+    #[test]
+    fn test_build_bitbucket_permalink_from_ssh_url() {
+        let remote = ParsedGitRemote {
+            owner: "thorstenzed",
+            repo: "testingrepo",
+        };
+        let permalink = Bitbucket.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "f00b4r",
+                path: "main.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://bitbucket.org/thorstenzed/testingrepo/src/f00b4r/main.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_bitbucket_permalink_from_ssh_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "thorstenzed",
+            repo: "testingrepo",
+        };
+        let permalink = Bitbucket.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "f00b4r",
+                path: "main.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url =
+            "https://bitbucket.org/thorstenzed/testingrepo/src/f00b4r/main.rs#lines-7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_bitbucket_permalink_from_ssh_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "thorstenzed",
+            repo: "testingrepo",
+        };
+        let permalink = Bitbucket.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "f00b4r",
+                path: "main.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url =
+            "https://bitbucket.org/thorstenzed/testingrepo/src/f00b4r/main.rs#lines-24:48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+}

crates/git_hosting_providers/src/providers/codeberg.rs

@@ -0,0 +1,290 @@
+use std::sync::Arc;
+
+use anyhow::{bail, Context, Result};
+use async_trait::async_trait;
+use futures::AsyncReadExt;
+use isahc::config::Configurable;
+use isahc::{AsyncBody, Request};
+use serde::Deserialize;
+use url::Url;
+use util::http::HttpClient;
+
+use git::{
+    BuildCommitPermalinkParams, BuildPermalinkParams, GitHostingProvider, Oid, ParsedGitRemote,
+};
+
+#[derive(Debug, Deserialize)]
+struct CommitDetails {
+    commit: Commit,
+    author: Option<User>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Commit {
+    author: Author,
+}
+
+#[derive(Debug, Deserialize)]
+struct Author {
+    name: String,
+    email: String,
+    date: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct User {
+    pub login: String,
+    pub id: u64,
+    pub avatar_url: String,
+}
+
+pub struct Codeberg;
+
+impl Codeberg {
+    async fn fetch_codeberg_commit_author(
+        &self,
+        repo_owner: &str,
+        repo: &str,
+        commit: &str,
+        client: &Arc<dyn HttpClient>,
+    ) -> Result<Option<User>> {
+        let url =
+            format!("https://codeberg.org/api/v1/repos/{repo_owner}/{repo}/git/commits/{commit}");
+
+        let mut request = Request::get(&url)
+            .redirect_policy(isahc::config::RedirectPolicy::Follow)
+            .header("Content-Type", "application/json");
+
+        if let Ok(codeberg_token) = std::env::var("CODEBERG_TOKEN") {
+            request = request.header("Authorization", format!("Bearer {}", codeberg_token));
+        }
+
+        let mut response = client
+            .send(request.body(AsyncBody::default())?)
+            .await
+            .with_context(|| format!("error fetching Codeberg commit details at {:?}", url))?;
+
+        let mut body = Vec::new();
+        response.body_mut().read_to_end(&mut body).await?;
+
+        if response.status().is_client_error() {
+            let text = String::from_utf8_lossy(body.as_slice());
+            bail!(
+                "status error {}, response: {text:?}",
+                response.status().as_u16()
+            );
+        }
+
+        let body_str = std::str::from_utf8(&body)?;
+
+        serde_json::from_str::<CommitDetails>(body_str)
+            .map(|commit| commit.author)
+            .context("failed to deserialize Codeberg commit details")
+    }
+}
+
+#[async_trait]
+impl GitHostingProvider for Codeberg {
+    fn name(&self) -> String {
+        "Codeberg".to_string()
+    }
+
+    fn base_url(&self) -> Url {
+        Url::parse("https://codeberg.org").unwrap()
+    }
+
+    fn supports_avatars(&self) -> bool {
+        true
+    }
+
+    fn format_line_number(&self, line: u32) -> String {
+        format!("L{line}")
+    }
+
+    fn format_line_numbers(&self, start_line: u32, end_line: u32) -> String {
+        format!("L{start_line}-L{end_line}")
+    }
+
+    fn parse_remote_url<'a>(&self, url: &'a str) -> Option<ParsedGitRemote<'a>> {
+        if url.starts_with("git@codeberg.org:") || url.starts_with("https://codeberg.org/") {
+            let repo_with_owner = url
+                .trim_start_matches("git@codeberg.org:")
+                .trim_start_matches("https://codeberg.org/")
+                .trim_end_matches(".git");
+
+            let (owner, repo) = repo_with_owner.split_once('/')?;
+
+            return Some(ParsedGitRemote { owner, repo });
+        }
+
+        None
+    }
+
+    fn build_commit_permalink(
+        &self,
+        remote: &ParsedGitRemote,
+        params: BuildCommitPermalinkParams,
+    ) -> Url {
+        let BuildCommitPermalinkParams { sha } = params;
+        let ParsedGitRemote { owner, repo } = remote;
+
+        self.base_url()
+            .join(&format!("{owner}/{repo}/commit/{sha}"))
+            .unwrap()
+    }
+
+    fn build_permalink(&self, remote: ParsedGitRemote, params: BuildPermalinkParams) -> Url {
+        let ParsedGitRemote { owner, repo } = remote;
+        let BuildPermalinkParams {
+            sha,
+            path,
+            selection,
+        } = params;
+
+        let mut permalink = self
+            .base_url()
+            .join(&format!("{owner}/{repo}/src/commit/{sha}/{path}"))
+            .unwrap();
+        permalink.set_fragment(
+            selection
+                .map(|selection| self.line_fragment(&selection))
+                .as_deref(),
+        );
+        permalink
+    }
+
+    async fn commit_author_avatar_url(
+        &self,
+        repo_owner: &str,
+        repo: &str,
+        commit: Oid,
+        http_client: Arc<dyn HttpClient>,
+    ) -> Result<Option<Url>> {
+        let commit = commit.to_string();
+        let avatar_url = self
+            .fetch_codeberg_commit_author(repo_owner, repo, &commit, &http_client)
+            .await?
+            .map(|author| Url::parse(&author.avatar_url))
+            .transpose()?;
+        Ok(avatar_url)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_codeberg_permalink_from_ssh_url() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Codeberg.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://codeberg.org/rajveermalviya/zed/src/commit/faa6f979be417239b2e070dbbf6392b909224e0b/crates/editor/src/git/permalink.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_codeberg_permalink_from_ssh_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Codeberg.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://codeberg.org/rajveermalviya/zed/src/commit/faa6f979be417239b2e070dbbf6392b909224e0b/crates/editor/src/git/permalink.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_codeberg_permalink_from_ssh_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Codeberg.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://codeberg.org/rajveermalviya/zed/src/commit/faa6f979be417239b2e070dbbf6392b909224e0b/crates/editor/src/git/permalink.rs#L24-L48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_codeberg_permalink_from_https_url() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Codeberg.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/zed/src/main.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://codeberg.org/rajveermalviya/zed/src/commit/faa6f979be417239b2e070dbbf6392b909224e0b/crates/zed/src/main.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_codeberg_permalink_from_https_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Codeberg.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/zed/src/main.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://codeberg.org/rajveermalviya/zed/src/commit/faa6f979be417239b2e070dbbf6392b909224e0b/crates/zed/src/main.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_codeberg_permalink_from_https_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Codeberg.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/zed/src/main.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://codeberg.org/rajveermalviya/zed/src/commit/faa6f979be417239b2e070dbbf6392b909224e0b/crates/zed/src/main.rs#L24-L48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+}

crates/git_hosting_providers/src/providers/gitee.rs

@@ -0,0 +1,194 @@
+use url::Url;
+
+use git::{BuildCommitPermalinkParams, BuildPermalinkParams, GitHostingProvider, ParsedGitRemote};
+
+pub struct Gitee;
+
+impl GitHostingProvider for Gitee {
+    fn name(&self) -> String {
+        "Gitee".to_string()
+    }
+
+    fn base_url(&self) -> Url {
+        Url::parse("https://gitee.com").unwrap()
+    }
+
+    fn supports_avatars(&self) -> bool {
+        false
+    }
+
+    fn format_line_number(&self, line: u32) -> String {
+        format!("L{line}")
+    }
+
+    fn format_line_numbers(&self, start_line: u32, end_line: u32) -> String {
+        format!("L{start_line}-{end_line}")
+    }
+
+    fn parse_remote_url<'a>(&self, url: &'a str) -> Option<ParsedGitRemote<'a>> {
+        if url.starts_with("git@gitee.com:") || url.starts_with("https://gitee.com/") {
+            let repo_with_owner = url
+                .trim_start_matches("git@gitee.com:")
+                .trim_start_matches("https://gitee.com/")
+                .trim_end_matches(".git");
+
+            let (owner, repo) = repo_with_owner.split_once('/')?;
+
+            return Some(ParsedGitRemote { owner, repo });
+        }
+
+        None
+    }
+
+    fn build_commit_permalink(
+        &self,
+        remote: &ParsedGitRemote,
+        params: BuildCommitPermalinkParams,
+    ) -> Url {
+        let BuildCommitPermalinkParams { sha } = params;
+        let ParsedGitRemote { owner, repo } = remote;
+
+        self.base_url()
+            .join(&format!("{owner}/{repo}/commit/{sha}"))
+            .unwrap()
+    }
+
+    fn build_permalink(&self, remote: ParsedGitRemote, params: BuildPermalinkParams) -> Url {
+        let ParsedGitRemote { owner, repo } = remote;
+        let BuildPermalinkParams {
+            sha,
+            path,
+            selection,
+        } = params;
+
+        let mut permalink = self
+            .base_url()
+            .join(&format!("{owner}/{repo}/blob/{sha}/{path}"))
+            .unwrap();
+        permalink.set_fragment(
+            selection
+                .map(|selection| self.line_fragment(&selection))
+                .as_deref(),
+        );
+        permalink
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_gitee_permalink_from_ssh_url() {
+        let remote = ParsedGitRemote {
+            owner: "libkitten",
+            repo: "zed",
+        };
+        let permalink = Gitee.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e5fe811d7ad0fc26934edd76f891d20bdc3bb194",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://gitee.com/libkitten/zed/blob/e5fe811d7ad0fc26934edd76f891d20bdc3bb194/crates/editor/src/git/permalink.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitee_permalink_from_ssh_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "libkitten",
+            repo: "zed",
+        };
+        let permalink = Gitee.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e5fe811d7ad0fc26934edd76f891d20bdc3bb194",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://gitee.com/libkitten/zed/blob/e5fe811d7ad0fc26934edd76f891d20bdc3bb194/crates/editor/src/git/permalink.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitee_permalink_from_ssh_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "libkitten",
+            repo: "zed",
+        };
+        let permalink = Gitee.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e5fe811d7ad0fc26934edd76f891d20bdc3bb194",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://gitee.com/libkitten/zed/blob/e5fe811d7ad0fc26934edd76f891d20bdc3bb194/crates/editor/src/git/permalink.rs#L24-48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitee_permalink_from_https_url() {
+        let remote = ParsedGitRemote {
+            owner: "libkitten",
+            repo: "zed",
+        };
+        let permalink = Gitee.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e5fe811d7ad0fc26934edd76f891d20bdc3bb194",
+                path: "crates/zed/src/main.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://gitee.com/libkitten/zed/blob/e5fe811d7ad0fc26934edd76f891d20bdc3bb194/crates/zed/src/main.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitee_permalink_from_https_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "libkitten",
+            repo: "zed",
+        };
+        let permalink = Gitee.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e5fe811d7ad0fc26934edd76f891d20bdc3bb194",
+                path: "crates/zed/src/main.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://gitee.com/libkitten/zed/blob/e5fe811d7ad0fc26934edd76f891d20bdc3bb194/crates/zed/src/main.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitee_permalink_from_https_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "libkitten",
+            repo: "zed",
+        };
+        let permalink = Gitee.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e5fe811d7ad0fc26934edd76f891d20bdc3bb194",
+                path: "crates/zed/src/main.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://gitee.com/libkitten/zed/blob/e5fe811d7ad0fc26934edd76f891d20bdc3bb194/crates/zed/src/main.rs#L24-48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+}

crates/git_hosting_providers/src/providers/github.rs

@@ -0,0 +1,354 @@
+use std::sync::{Arc, OnceLock};
+
+use anyhow::{bail, Context, Result};
+use async_trait::async_trait;
+use futures::AsyncReadExt;
+use isahc::config::Configurable;
+use isahc::{AsyncBody, Request};
+use regex::Regex;
+use serde::Deserialize;
+use url::Url;
+use util::http::HttpClient;
+
+use git::{
+    BuildCommitPermalinkParams, BuildPermalinkParams, GitHostingProvider, Oid, ParsedGitRemote,
+    PullRequest,
+};
+
+fn pull_request_number_regex() -> &'static Regex {
+    static PULL_REQUEST_NUMBER_REGEX: OnceLock<Regex> = OnceLock::new();
+
+    PULL_REQUEST_NUMBER_REGEX.get_or_init(|| Regex::new(r"\(#(\d+)\)$").unwrap())
+}
+
+#[derive(Debug, Deserialize)]
+struct CommitDetails {
+    commit: Commit,
+    author: Option<User>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Commit {
+    author: Author,
+}
+
+#[derive(Debug, Deserialize)]
+struct Author {
+    email: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct User {
+    pub id: u64,
+    pub avatar_url: String,
+}
+
+pub struct Github;
+
+impl Github {
+    async fn fetch_github_commit_author(
+        &self,
+        repo_owner: &str,
+        repo: &str,
+        commit: &str,
+        client: &Arc<dyn HttpClient>,
+    ) -> Result<Option<User>> {
+        let url = format!("https://api.github.com/repos/{repo_owner}/{repo}/commits/{commit}");
+
+        let mut request = Request::get(&url)
+            .redirect_policy(isahc::config::RedirectPolicy::Follow)
+            .header("Content-Type", "application/json");
+
+        if let Ok(github_token) = std::env::var("GITHUB_TOKEN") {
+            request = request.header("Authorization", format!("Bearer {}", github_token));
+        }
+
+        let mut response = client
+            .send(request.body(AsyncBody::default())?)
+            .await
+            .with_context(|| format!("error fetching GitHub commit details at {:?}", url))?;
+
+        let mut body = Vec::new();
+        response.body_mut().read_to_end(&mut body).await?;
+
+        if response.status().is_client_error() {
+            let text = String::from_utf8_lossy(body.as_slice());
+            bail!(
+                "status error {}, response: {text:?}",
+                response.status().as_u16()
+            );
+        }
+
+        let body_str = std::str::from_utf8(&body)?;
+
+        serde_json::from_str::<CommitDetails>(body_str)
+            .map(|commit| commit.author)
+            .context("failed to deserialize GitHub commit details")
+    }
+}
+
+#[async_trait]
+impl GitHostingProvider for Github {
+    fn name(&self) -> String {
+        "GitHub".to_string()
+    }
+
+    fn base_url(&self) -> Url {
+        Url::parse("https://github.com").unwrap()
+    }
+
+    fn supports_avatars(&self) -> bool {
+        true
+    }
+
+    fn format_line_number(&self, line: u32) -> String {
+        format!("L{line}")
+    }
+
+    fn format_line_numbers(&self, start_line: u32, end_line: u32) -> String {
+        format!("L{start_line}-L{end_line}")
+    }
+
+    fn parse_remote_url<'a>(&self, url: &'a str) -> Option<ParsedGitRemote<'a>> {
+        if url.starts_with("git@github.com:") || url.starts_with("https://github.com/") {
+            let repo_with_owner = url
+                .trim_start_matches("git@github.com:")
+                .trim_start_matches("https://github.com/")
+                .trim_end_matches(".git");
+
+            let (owner, repo) = repo_with_owner.split_once('/')?;
+
+            return Some(ParsedGitRemote { owner, repo });
+        }
+
+        None
+    }
+
+    fn build_commit_permalink(
+        &self,
+        remote: &ParsedGitRemote,
+        params: BuildCommitPermalinkParams,
+    ) -> Url {
+        let BuildCommitPermalinkParams { sha } = params;
+        let ParsedGitRemote { owner, repo } = remote;
+
+        self.base_url()
+            .join(&format!("{owner}/{repo}/commit/{sha}"))
+            .unwrap()
+    }
+
+    fn build_permalink(&self, remote: ParsedGitRemote, params: BuildPermalinkParams) -> Url {
+        let ParsedGitRemote { owner, repo } = remote;
+        let BuildPermalinkParams {
+            sha,
+            path,
+            selection,
+        } = params;
+
+        let mut permalink = self
+            .base_url()
+            .join(&format!("{owner}/{repo}/blob/{sha}/{path}"))
+            .unwrap();
+        permalink.set_fragment(
+            selection
+                .map(|selection| self.line_fragment(&selection))
+                .as_deref(),
+        );
+        permalink
+    }
+
+    fn extract_pull_request(&self, remote: &ParsedGitRemote, message: &str) -> Option<PullRequest> {
+        let line = message.lines().next()?;
+        let capture = pull_request_number_regex().captures(line)?;
+        let number = capture.get(1)?.as_str().parse::<u32>().ok()?;
+
+        let mut url = self.base_url();
+        let path = format!("/{}/{}/pull/{}", remote.owner, remote.repo, number);
+        url.set_path(&path);
+
+        Some(PullRequest { number, url })
+    }
+
+    async fn commit_author_avatar_url(
+        &self,
+        repo_owner: &str,
+        repo: &str,
+        commit: Oid,
+        http_client: Arc<dyn HttpClient>,
+    ) -> Result<Option<Url>> {
+        let commit = commit.to_string();
+        let avatar_url = self
+            .fetch_github_commit_author(repo_owner, repo, &commit, &http_client)
+            .await?
+            .map(|author| -> Result<Url, url::ParseError> {
+                let mut url = Url::parse(&author.avatar_url)?;
+                url.set_query(Some("size=128"));
+                Ok(url)
+            })
+            .transpose()?;
+        Ok(avatar_url)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    // TODO: Replace with `indoc`.
+    use unindent::Unindent;
+
+    use super::*;
+
+    #[test]
+    fn test_build_github_permalink_from_ssh_url() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Github.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://github.com/zed-industries/zed/blob/e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7/crates/editor/src/git/permalink.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_github_permalink_from_ssh_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Github.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://github.com/zed-industries/zed/blob/e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7/crates/editor/src/git/permalink.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_github_permalink_from_ssh_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Github.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://github.com/zed-industries/zed/blob/e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7/crates/editor/src/git/permalink.rs#L24-L48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_github_permalink_from_https_url() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Github.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "b2efec9824c45fcc90c9a7eb107a50d1772a60aa",
+                path: "crates/zed/src/main.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://github.com/zed-industries/zed/blob/b2efec9824c45fcc90c9a7eb107a50d1772a60aa/crates/zed/src/main.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_github_permalink_from_https_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Github.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "b2efec9824c45fcc90c9a7eb107a50d1772a60aa",
+                path: "crates/zed/src/main.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://github.com/zed-industries/zed/blob/b2efec9824c45fcc90c9a7eb107a50d1772a60aa/crates/zed/src/main.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_github_permalink_from_https_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Github.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "b2efec9824c45fcc90c9a7eb107a50d1772a60aa",
+                path: "crates/zed/src/main.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://github.com/zed-industries/zed/blob/b2efec9824c45fcc90c9a7eb107a50d1772a60aa/crates/zed/src/main.rs#L24-L48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_github_pull_requests() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+
+        let message = "This does not contain a pull request";
+        assert!(Github.extract_pull_request(&remote, message).is_none());
+
+        // Pull request number at end of first line
+        let message = r#"
+            project panel: do not expand collapsed worktrees on "collapse all entries" (#10687)
+
+            Fixes #10597
+
+            Release Notes:
+
+            - Fixed "project panel: collapse all entries" expanding collapsed worktrees.
+            "#
+        .unindent();
+
+        assert_eq!(
+            Github
+                .extract_pull_request(&remote, &message)
+                .unwrap()
+                .url
+                .as_str(),
+            "https://github.com/zed-industries/zed/pull/10687"
+        );
+
+        // Pull request number in middle of line, which we want to ignore
+        let message = r#"
+            Follow-up to #10687 to fix problems
+
+            See the original PR, this is a fix.
+            "#
+        .unindent();
+        assert_eq!(Github.extract_pull_request(&remote, &message), None);
+    }
+}

crates/git_hosting_providers/src/providers/gitlab.rs

@@ -0,0 +1,194 @@
+use url::Url;
+
+use git::{BuildCommitPermalinkParams, BuildPermalinkParams, GitHostingProvider, ParsedGitRemote};
+
+pub struct Gitlab;
+
+impl GitHostingProvider for Gitlab {
+    fn name(&self) -> String {
+        "GitLab".to_string()
+    }
+
+    fn base_url(&self) -> Url {
+        Url::parse("https://gitlab.com").unwrap()
+    }
+
+    fn supports_avatars(&self) -> bool {
+        false
+    }
+
+    fn format_line_number(&self, line: u32) -> String {
+        format!("L{line}")
+    }
+
+    fn format_line_numbers(&self, start_line: u32, end_line: u32) -> String {
+        format!("L{start_line}-{end_line}")
+    }
+
+    fn parse_remote_url<'a>(&self, url: &'a str) -> Option<ParsedGitRemote<'a>> {
+        if url.starts_with("git@gitlab.com:") || url.starts_with("https://gitlab.com/") {
+            let repo_with_owner = url
+                .trim_start_matches("git@gitlab.com:")
+                .trim_start_matches("https://gitlab.com/")
+                .trim_end_matches(".git");
+
+            let (owner, repo) = repo_with_owner.split_once('/')?;
+
+            return Some(ParsedGitRemote { owner, repo });
+        }
+
+        None
+    }
+
+    fn build_commit_permalink(
+        &self,
+        remote: &ParsedGitRemote,
+        params: BuildCommitPermalinkParams,
+    ) -> Url {
+        let BuildCommitPermalinkParams { sha } = params;
+        let ParsedGitRemote { owner, repo } = remote;
+
+        self.base_url()
+            .join(&format!("{owner}/{repo}/-/commit/{sha}"))
+            .unwrap()
+    }
+
+    fn build_permalink(&self, remote: ParsedGitRemote, params: BuildPermalinkParams) -> Url {
+        let ParsedGitRemote { owner, repo } = remote;
+        let BuildPermalinkParams {
+            sha,
+            path,
+            selection,
+        } = params;
+
+        let mut permalink = self
+            .base_url()
+            .join(&format!("{owner}/{repo}/-/blob/{sha}/{path}"))
+            .unwrap();
+        permalink.set_fragment(
+            selection
+                .map(|selection| self.line_fragment(&selection))
+                .as_deref(),
+        );
+        permalink
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_gitlab_permalink_from_ssh_url() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Gitlab.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://gitlab.com/zed-industries/zed/-/blob/e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7/crates/editor/src/git/permalink.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitlab_permalink_from_ssh_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Gitlab.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://gitlab.com/zed-industries/zed/-/blob/e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7/crates/editor/src/git/permalink.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitlab_permalink_from_ssh_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Gitlab.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://gitlab.com/zed-industries/zed/-/blob/e6ebe7974deb6bb6cc0e2595c8ec31f0c71084b7/crates/editor/src/git/permalink.rs#L24-48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitlab_permalink_from_https_url() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Gitlab.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "b2efec9824c45fcc90c9a7eb107a50d1772a60aa",
+                path: "crates/zed/src/main.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://gitlab.com/zed-industries/zed/-/blob/b2efec9824c45fcc90c9a7eb107a50d1772a60aa/crates/zed/src/main.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitlab_permalink_from_https_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Gitlab.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "b2efec9824c45fcc90c9a7eb107a50d1772a60aa",
+                path: "crates/zed/src/main.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://gitlab.com/zed-industries/zed/-/blob/b2efec9824c45fcc90c9a7eb107a50d1772a60aa/crates/zed/src/main.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_gitlab_permalink_from_https_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "zed-industries",
+            repo: "zed",
+        };
+        let permalink = Gitlab.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "b2efec9824c45fcc90c9a7eb107a50d1772a60aa",
+                path: "crates/zed/src/main.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://gitlab.com/zed-industries/zed/-/blob/b2efec9824c45fcc90c9a7eb107a50d1772a60aa/crates/zed/src/main.rs#L24-48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+}

crates/git_hosting_providers/src/providers/sourcehut.rs

@@ -0,0 +1,215 @@
+use url::Url;
+
+use git::{BuildCommitPermalinkParams, BuildPermalinkParams, GitHostingProvider, ParsedGitRemote};
+
+pub struct Sourcehut;
+
+impl GitHostingProvider for Sourcehut {
+    fn name(&self) -> String {
+        "Gitee".to_string()
+    }
+
+    fn base_url(&self) -> Url {
+        Url::parse("https://git.sr.ht").unwrap()
+    }
+
+    fn supports_avatars(&self) -> bool {
+        false
+    }
+
+    fn format_line_number(&self, line: u32) -> String {
+        format!("L{line}")
+    }
+
+    fn format_line_numbers(&self, start_line: u32, end_line: u32) -> String {
+        format!("L{start_line}-{end_line}")
+    }
+
+    fn parse_remote_url<'a>(&self, url: &'a str) -> Option<ParsedGitRemote<'a>> {
+        if url.starts_with("git@git.sr.ht:") || url.starts_with("https://git.sr.ht/") {
+            // sourcehut indicates a repo with '.git' suffix as a separate repo.
+            // For example, "git@git.sr.ht:~username/repo" and "git@git.sr.ht:~username/repo.git"
+            // are two distinct repositories.
+            let repo_with_owner = url
+                .trim_start_matches("git@git.sr.ht:~")
+                .trim_start_matches("https://git.sr.ht/~");
+
+            let (owner, repo) = repo_with_owner.split_once('/')?;
+
+            return Some(ParsedGitRemote { owner, repo });
+        }
+
+        None
+    }
+
+    fn build_commit_permalink(
+        &self,
+        remote: &ParsedGitRemote,
+        params: BuildCommitPermalinkParams,
+    ) -> Url {
+        let BuildCommitPermalinkParams { sha } = params;
+        let ParsedGitRemote { owner, repo } = remote;
+
+        self.base_url()
+            .join(&format!("~{owner}/{repo}/commit/{sha}"))
+            .unwrap()
+    }
+
+    fn build_permalink(&self, remote: ParsedGitRemote, params: BuildPermalinkParams) -> Url {
+        let ParsedGitRemote { owner, repo } = remote;
+        let BuildPermalinkParams {
+            sha,
+            path,
+            selection,
+        } = params;
+
+        let mut permalink = self
+            .base_url()
+            .join(&format!("~{owner}/{repo}/tree/{sha}/item/{path}"))
+            .unwrap();
+        permalink.set_fragment(
+            selection
+                .map(|selection| self.line_fragment(&selection))
+                .as_deref(),
+        );
+        permalink
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_sourcehut_permalink_from_ssh_url() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Sourcehut.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://git.sr.ht/~rajveermalviya/zed/tree/faa6f979be417239b2e070dbbf6392b909224e0b/item/crates/editor/src/git/permalink.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_sourcehut_permalink_from_ssh_url_with_git_prefix() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed.git",
+        };
+        let permalink = Sourcehut.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://git.sr.ht/~rajveermalviya/zed.git/tree/faa6f979be417239b2e070dbbf6392b909224e0b/item/crates/editor/src/git/permalink.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_sourcehut_permalink_from_ssh_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Sourcehut.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://git.sr.ht/~rajveermalviya/zed/tree/faa6f979be417239b2e070dbbf6392b909224e0b/item/crates/editor/src/git/permalink.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_sourcehut_permalink_from_ssh_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Sourcehut.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/editor/src/git/permalink.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://git.sr.ht/~rajveermalviya/zed/tree/faa6f979be417239b2e070dbbf6392b909224e0b/item/crates/editor/src/git/permalink.rs#L24-48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_sourcehut_permalink_from_https_url() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Sourcehut.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/zed/src/main.rs",
+                selection: None,
+            },
+        );
+
+        let expected_url = "https://git.sr.ht/~rajveermalviya/zed/tree/faa6f979be417239b2e070dbbf6392b909224e0b/item/crates/zed/src/main.rs";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_sourcehut_permalink_from_https_url_single_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Sourcehut.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/zed/src/main.rs",
+                selection: Some(6..6),
+            },
+        );
+
+        let expected_url = "https://git.sr.ht/~rajveermalviya/zed/tree/faa6f979be417239b2e070dbbf6392b909224e0b/item/crates/zed/src/main.rs#L7";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+
+    #[test]
+    fn test_build_sourcehut_permalink_from_https_url_multi_line_selection() {
+        let remote = ParsedGitRemote {
+            owner: "rajveermalviya",
+            repo: "zed",
+        };
+        let permalink = Sourcehut.build_permalink(
+            remote,
+            BuildPermalinkParams {
+                sha: "faa6f979be417239b2e070dbbf6392b909224e0b",
+                path: "crates/zed/src/main.rs",
+                selection: Some(23..47),
+            },
+        );
+
+        let expected_url = "https://git.sr.ht/~rajveermalviya/zed/tree/faa6f979be417239b2e070dbbf6392b909224e0b/item/crates/zed/src/main.rs#L24-48";
+        assert_eq!(permalink.to_string(), expected_url.to_string())
+    }
+}