feat: copy note git URLs
This commit is contained in:
lucaronin
@@ -150,6 +150,19 @@ pub async fn git_remote_status(vault_path: VaultPathArg) -> Result<GitRemoteStat
|
||||
.map_err(|e| format!("Task panicked: {e}"))?
|
||||
}
|
||||
|
||||
#[cfg(desktop)]
|
||||
#[tauri::command]
|
||||
pub async fn git_file_url(
|
||||
vault_path: VaultPathArg,
|
||||
path: NotePathArg,
|
||||
) -> Result<Option<String>, String> {
|
||||
let vault_path = expand_tilde(&vault_path).into_owned();
|
||||
let path = expand_tilde(&path).into_owned();
|
||||
tokio::task::spawn_blocking(move || crate::git::git_file_url(&vault_path, &path))
|
||||
.await
|
||||
.map_err(|e| format!("Task panicked: {e}"))?
|
||||
}
|
||||
|
||||
#[cfg(desktop)]
|
||||
#[tauri::command]
|
||||
pub fn git_discard_file(
|
||||
@@ -344,6 +357,15 @@ pub async fn git_remote_status(_vault_path: VaultPathArg) -> Result<GitRemoteSta
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(mobile)]
|
||||
#[tauri::command]
|
||||
pub async fn git_file_url(
|
||||
_vault_path: VaultPathArg,
|
||||
_path: NotePathArg,
|
||||
) -> Result<Option<String>, String> {
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
#[cfg(mobile)]
|
||||
#[tauri::command]
|
||||
pub fn git_discard_file(
|
||||
|
||||
403
src-tauri/src/git/file_url.rs
Normal file
403
src-tauri/src/git/file_url.rs
Normal file
@@ -0,0 +1,403 @@
|
||||
use std::path::Path;
|
||||
|
||||
use crate::vault::path_identity::vault_relative_path_string;
|
||||
|
||||
use super::command::{git_output, stderr_or_failure, stdout_text};
|
||||
use super::remote_config::primary_remote_url;
|
||||
|
||||
enum RemoteWebKind {
|
||||
Bitbucket,
|
||||
Gitea,
|
||||
GitLab,
|
||||
Generic,
|
||||
}
|
||||
|
||||
struct RemoteWebBase {
|
||||
base_url: String,
|
||||
kind: RemoteWebKind,
|
||||
}
|
||||
|
||||
struct GitFileLocation {
|
||||
branch: BranchName,
|
||||
relative_path: RelativeGitPath,
|
||||
}
|
||||
|
||||
struct BranchName(String);
|
||||
|
||||
struct RelativeGitPath(String);
|
||||
|
||||
struct RemoteUrl(String);
|
||||
|
||||
struct RemoteParts {
|
||||
host: RemoteHost,
|
||||
repo_path: RepoPath,
|
||||
}
|
||||
|
||||
struct RemoteHost(String);
|
||||
|
||||
struct RepoPath(String);
|
||||
|
||||
pub fn git_file_url(vault_path: &str, file_path: &str) -> Result<Option<String>, String> {
|
||||
let vault = Path::new(vault_path);
|
||||
let file = Path::new(file_path);
|
||||
let Some(relative_path) = RelativeGitPath::from_paths(vault, file)? else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
let Some(remote_url) = primary_remote_url(vault)?.map(RemoteUrl::new) else {
|
||||
return Ok(None);
|
||||
};
|
||||
let location = GitFileLocation::new(current_ref_name(vault)?, relative_path);
|
||||
|
||||
let url = match remote_web_base(&remote_url) {
|
||||
Some(remote) => remote.file_url(&location),
|
||||
None => remote_url.git_fragment_url(&location),
|
||||
};
|
||||
Ok(Some(url))
|
||||
}
|
||||
|
||||
fn current_ref_name(vault: &Path) -> Result<BranchName, String> {
|
||||
let output = git_output(vault, &["branch", "--show-current"])
|
||||
.map_err(|e| format!("Failed to get branch: {e}"))?;
|
||||
|
||||
if !output.status.success() {
|
||||
return Err(stderr_or_failure("git branch", &output));
|
||||
}
|
||||
|
||||
let branch = stdout_text(&output);
|
||||
Ok(BranchName::new(branch))
|
||||
}
|
||||
|
||||
impl GitFileLocation {
|
||||
fn new(branch: BranchName, relative_path: RelativeGitPath) -> Self {
|
||||
Self {
|
||||
branch,
|
||||
relative_path,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl BranchName {
|
||||
fn new(value: String) -> Self {
|
||||
if value.is_empty() {
|
||||
return Self("HEAD".to_string());
|
||||
}
|
||||
Self(value)
|
||||
}
|
||||
|
||||
fn encoded_fragment(&self) -> String {
|
||||
encode_fragment_part(&self.0)
|
||||
}
|
||||
|
||||
fn encoded_path(&self) -> String {
|
||||
encode_path(&self.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl RelativeGitPath {
|
||||
fn from_paths(vault: &Path, file: &Path) -> Result<Option<Self>, String> {
|
||||
let value = vault_relative_path_string(vault, file)?;
|
||||
if value.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some(Self(value)))
|
||||
}
|
||||
|
||||
fn encoded_fragment(&self) -> String {
|
||||
encode_fragment_part(&self.0)
|
||||
}
|
||||
|
||||
fn encoded_path(&self) -> String {
|
||||
encode_path(&self.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl RemoteWebBase {
|
||||
fn file_url(&self, location: &GitFileLocation) -> String {
|
||||
let branch = location.branch.encoded_path();
|
||||
let path = location.relative_path.encoded_path();
|
||||
match self.kind {
|
||||
RemoteWebKind::Bitbucket => format!("{}/src/{}/{}", self.base_url, branch, path),
|
||||
RemoteWebKind::Gitea => format!("{}/src/branch/{}/{}", self.base_url, branch, path),
|
||||
RemoteWebKind::GitLab => format!("{}/-/blob/{}/{}", self.base_url, branch, path),
|
||||
RemoteWebKind::Generic => format!("{}/blob/{}/{}", self.base_url, branch, path),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RemoteUrl {
|
||||
fn new(value: String) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
|
||||
fn trimmed(&self) -> &str {
|
||||
self.0.trim()
|
||||
}
|
||||
|
||||
fn git_fragment_url(&self, location: &GitFileLocation) -> String {
|
||||
format!(
|
||||
"{}#{}:{}",
|
||||
self.trimmed(),
|
||||
location.branch.encoded_fragment(),
|
||||
location.relative_path.encoded_fragment(),
|
||||
)
|
||||
}
|
||||
|
||||
fn host_and_path(&self) -> Option<RemoteParts> {
|
||||
self.http_parts()
|
||||
.or_else(|| self.scheme_parts())
|
||||
.or_else(|| self.scp_parts())
|
||||
}
|
||||
|
||||
fn http_parts(&self) -> Option<RemoteParts> {
|
||||
let rest = self
|
||||
.trimmed()
|
||||
.strip_prefix("https://")
|
||||
.or_else(|| self.trimmed().strip_prefix("http://"))?;
|
||||
RemoteParts::from_authority_path(rest)
|
||||
}
|
||||
|
||||
fn scheme_parts(&self) -> Option<RemoteParts> {
|
||||
let rest = self
|
||||
.trimmed()
|
||||
.strip_prefix("ssh://")
|
||||
.or_else(|| self.trimmed().strip_prefix("git://"))?;
|
||||
RemoteParts::from_authority_path(rest)
|
||||
}
|
||||
|
||||
fn scp_parts(&self) -> Option<RemoteParts> {
|
||||
let (_, target) = self.trimmed().split_once('@')?;
|
||||
let (host, path) = target.split_once(':')?;
|
||||
Some(RemoteParts::new(RemoteHost::new(host), RepoPath::new(path)))
|
||||
}
|
||||
}
|
||||
|
||||
impl RemoteParts {
|
||||
fn new(host: RemoteHost, repo_path: RepoPath) -> Self {
|
||||
Self { host, repo_path }
|
||||
}
|
||||
|
||||
fn from_authority_path(value: &str) -> Option<Self> {
|
||||
let (authority, path) = value.split_once('/')?;
|
||||
Some(Self::new(
|
||||
RemoteHost::from_authority(authority),
|
||||
RepoPath::new(path),
|
||||
))
|
||||
}
|
||||
|
||||
fn into_web_base(self) -> Option<RemoteWebBase> {
|
||||
let clean_path = self.repo_path.clean();
|
||||
if self.host.is_empty() {
|
||||
return None;
|
||||
}
|
||||
if clean_path.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let base_url = format!("https://{}/{clean_path}", self.host.as_str());
|
||||
Some(RemoteWebBase {
|
||||
kind: remote_web_kind(&self.host),
|
||||
base_url,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl RemoteHost {
|
||||
fn new(value: &str) -> Self {
|
||||
Self(value.to_string())
|
||||
}
|
||||
|
||||
fn from_authority(authority: &str) -> Self {
|
||||
Self::new(authority.rsplit('@').next().unwrap_or_default())
|
||||
}
|
||||
|
||||
fn as_str(&self) -> &str {
|
||||
&self.0
|
||||
}
|
||||
|
||||
fn is_empty(&self) -> bool {
|
||||
self.0.is_empty()
|
||||
}
|
||||
|
||||
fn lower(&self) -> String {
|
||||
self.0.to_ascii_lowercase()
|
||||
}
|
||||
}
|
||||
|
||||
impl RepoPath {
|
||||
fn new(value: &str) -> Self {
|
||||
Self(value.to_string())
|
||||
}
|
||||
|
||||
fn clean(&self) -> &str {
|
||||
let trimmed = self.0.trim_matches('/');
|
||||
trimmed.strip_suffix(".git").unwrap_or(trimmed)
|
||||
}
|
||||
}
|
||||
|
||||
fn remote_web_base(remote_url: &RemoteUrl) -> Option<RemoteWebBase> {
|
||||
remote_url.host_and_path()?.into_web_base()
|
||||
}
|
||||
|
||||
fn remote_web_kind(host: &RemoteHost) -> RemoteWebKind {
|
||||
let lower_host = host.lower();
|
||||
if lower_host.contains("gitlab") {
|
||||
return RemoteWebKind::GitLab;
|
||||
}
|
||||
if lower_host.contains("bitbucket") {
|
||||
return RemoteWebKind::Bitbucket;
|
||||
}
|
||||
if lower_host.contains("gitea") {
|
||||
return RemoteWebKind::Gitea;
|
||||
}
|
||||
if lower_host.contains("forgejo") {
|
||||
return RemoteWebKind::Gitea;
|
||||
}
|
||||
if lower_host == "codeberg.org" {
|
||||
return RemoteWebKind::Gitea;
|
||||
}
|
||||
RemoteWebKind::Generic
|
||||
}
|
||||
|
||||
fn encode_path(path: &str) -> String {
|
||||
path.split('/')
|
||||
.map(encode_segment)
|
||||
.collect::<Vec<_>>()
|
||||
.join("/")
|
||||
}
|
||||
|
||||
fn encode_fragment_part(value: &str) -> String {
|
||||
let mut encoded = String::new();
|
||||
for byte in value.bytes() {
|
||||
match byte {
|
||||
b' ' => encoded.push_str("%20"),
|
||||
b'#' => encoded.push_str("%23"),
|
||||
b'%' => encoded.push_str("%25"),
|
||||
_ => encoded.push(char::from(byte)),
|
||||
}
|
||||
}
|
||||
encoded
|
||||
}
|
||||
|
||||
fn encode_segment(segment: &str) -> String {
|
||||
segment
|
||||
.bytes()
|
||||
.flat_map(|byte| {
|
||||
if is_unreserved_url_byte(byte) {
|
||||
vec![byte]
|
||||
} else {
|
||||
format!("%{byte:02X}").into_bytes()
|
||||
}
|
||||
})
|
||||
.map(char::from)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn is_unreserved_url_byte(byte: u8) -> bool {
|
||||
byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'.' | b'_' | b'~')
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::git::git_command;
|
||||
use crate::git::tests::setup_git_repo;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
struct RemoteFixture {
|
||||
name: &'static str,
|
||||
url: &'static str,
|
||||
}
|
||||
|
||||
struct GitUrlCase {
|
||||
remote: RemoteFixture,
|
||||
note_path: &'static str,
|
||||
expected_url: &'static str,
|
||||
}
|
||||
|
||||
fn add_remote(vault: &Path, remote: RemoteFixture) {
|
||||
git_command()
|
||||
.args(["remote", "add", remote.name, remote.url])
|
||||
.current_dir(vault)
|
||||
.output()
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn write_note(vault: &Path, relative_path: &str) -> String {
|
||||
let file = vault.join(relative_path);
|
||||
fs::create_dir_all(file.parent().unwrap()).unwrap();
|
||||
fs::write(&file, "# Note\n").unwrap();
|
||||
file.to_string_lossy().to_string()
|
||||
}
|
||||
|
||||
fn assert_git_file_url(test_case: GitUrlCase) {
|
||||
let dir = setup_git_repo();
|
||||
let note = write_note(dir.path(), test_case.note_path);
|
||||
add_remote(dir.path(), test_case.remote);
|
||||
|
||||
let url = git_file_url(dir.path().to_str().unwrap(), ¬e).unwrap();
|
||||
|
||||
assert_eq!(url.as_deref(), Some(test_case.expected_url));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_none_without_remote() {
|
||||
let dir = setup_git_repo();
|
||||
let note = write_note(dir.path(), "note.md");
|
||||
|
||||
let url = git_file_url(dir.path().to_str().unwrap(), ¬e).unwrap();
|
||||
|
||||
assert_eq!(url, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_none_outside_git_repository() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let note = write_note(dir.path(), "note.md");
|
||||
|
||||
let url = git_file_url(dir.path().to_str().unwrap(), ¬e).unwrap();
|
||||
|
||||
assert_eq!(url, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_remote_note_urls() {
|
||||
[
|
||||
GitUrlCase {
|
||||
remote: RemoteFixture {
|
||||
name: "origin",
|
||||
url: "git@github.com:owner/repo.git",
|
||||
},
|
||||
note_path: "Notes/Project Plan.md",
|
||||
expected_url: "https://github.com/owner/repo/blob/main/Notes/Project%20Plan.md",
|
||||
},
|
||||
GitUrlCase {
|
||||
remote: RemoteFixture {
|
||||
name: "origin",
|
||||
url: "https://gho_secret@github.com/owner/repo.git",
|
||||
},
|
||||
note_path: "private.md",
|
||||
expected_url: "https://github.com/owner/repo/blob/main/private.md",
|
||||
},
|
||||
GitUrlCase {
|
||||
remote: RemoteFixture {
|
||||
name: "origin",
|
||||
url: "https://gitlab.com/group/repo.git",
|
||||
},
|
||||
note_path: "notes/topic.md",
|
||||
expected_url: "https://gitlab.com/group/repo/-/blob/main/notes/topic.md",
|
||||
},
|
||||
GitUrlCase {
|
||||
remote: RemoteFixture {
|
||||
name: "upstream",
|
||||
url: "https://github.com/team/vault.git",
|
||||
},
|
||||
note_path: "shared.md",
|
||||
expected_url: "https://github.com/team/vault/blob/main/shared.md",
|
||||
},
|
||||
]
|
||||
.into_iter()
|
||||
.for_each(assert_git_file_url);
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,7 @@ mod conflict;
|
||||
mod connect;
|
||||
mod credentials;
|
||||
mod dates;
|
||||
mod file_url;
|
||||
mod history;
|
||||
mod pulse;
|
||||
mod remote;
|
||||
@@ -27,6 +28,7 @@ pub use conflict::{
|
||||
};
|
||||
pub use connect::{disconnect_all_remotes, git_add_remote, GitAddRemoteResult};
|
||||
pub use dates::{get_all_file_dates, GitDates};
|
||||
pub use file_url::git_file_url;
|
||||
pub use history::{get_file_diff, get_file_diff_at_commit, get_file_history};
|
||||
pub use pulse::{get_last_commit_info, get_vault_pulse, LastCommitInfo, PulseCommit, PulseFile};
|
||||
pub use remote::{
|
||||
|
||||
@@ -7,11 +7,33 @@ const REMOTE_URL_CONFIG_PATTERN: &str = r"^remote\..*\.url$";
|
||||
const ORIGIN_URL_CONFIG_KEY: &str = "remote.origin.url";
|
||||
const ORIGIN_FETCH_CONFIG_KEY: &str = "remote.origin.fetch";
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
struct ConfiguredRemote {
|
||||
name: String,
|
||||
url: String,
|
||||
}
|
||||
|
||||
pub(super) fn has_configured_remote(vault: &Path) -> Result<bool, String> {
|
||||
Ok(!list_configured_remotes(vault)?.is_empty())
|
||||
}
|
||||
|
||||
pub(super) fn list_configured_remotes(vault: &Path) -> Result<Vec<String>, String> {
|
||||
Ok(list_configured_remote_urls(vault)?
|
||||
.into_iter()
|
||||
.map(|remote| remote.name)
|
||||
.collect())
|
||||
}
|
||||
|
||||
pub(super) fn primary_remote_url(vault: &Path) -> Result<Option<String>, String> {
|
||||
let remotes = list_configured_remote_urls(vault)?;
|
||||
Ok(remotes
|
||||
.iter()
|
||||
.find(|remote| remote.name == "origin")
|
||||
.or_else(|| remotes.first())
|
||||
.map(|remote| remote.url.clone()))
|
||||
}
|
||||
|
||||
fn list_configured_remote_urls(vault: &Path) -> Result<Vec<ConfiguredRemote>, String> {
|
||||
let output = git_output(
|
||||
vault,
|
||||
&["config", "--get-regexp", REMOTE_URL_CONFIG_PATTERN],
|
||||
@@ -27,19 +49,26 @@ pub(super) fn list_configured_remotes(vault: &Path) -> Result<Vec<String>, Strin
|
||||
|
||||
Ok(stdout_lines(&output)
|
||||
.into_iter()
|
||||
.filter_map(|line| remote_name_from_url_config(&line))
|
||||
.filter_map(|line| remote_from_url_config(&line))
|
||||
.collect())
|
||||
}
|
||||
|
||||
fn remote_name_from_url_config(line: &str) -> Option<String> {
|
||||
fn remote_from_url_config(line: &str) -> Option<ConfiguredRemote> {
|
||||
let (key, value) = line.split_once(' ')?;
|
||||
if value.trim().is_empty() {
|
||||
let url = value.trim();
|
||||
if url.is_empty() {
|
||||
return None;
|
||||
}
|
||||
key.strip_prefix("remote.")
|
||||
let name = key
|
||||
.strip_prefix("remote.")
|
||||
.and_then(|name| name.strip_suffix(".url"))
|
||||
.filter(|name| !name.is_empty())
|
||||
.map(ToString::to_string)
|
||||
.map(ToString::to_string)?;
|
||||
|
||||
Some(ConfiguredRemote {
|
||||
name,
|
||||
url: url.to_string(),
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn configure_origin_remote(vault: &Path, remote_url: &str) -> Result<(), String> {
|
||||
|
||||
@@ -501,6 +501,7 @@ macro_rules! app_invoke_handler {
|
||||
commands::git_pull,
|
||||
commands::git_push,
|
||||
commands::git_remote_status,
|
||||
commands::git_file_url,
|
||||
commands::git_add_remote,
|
||||
commands::get_conflict_files,
|
||||
commands::get_conflict_mode,
|
||||
|
||||
Reference in New Issue
Block a user