git.rs

use crate::errors::{ Result, Error };

use serde::{ Serialize };

use std::ffi::{ OsStr };
use std::fmt;
use std::fs;
use std::path::{ Path, PathBuf };

pub(crate) use git2::{ Commit, Repository, ObjectType, Oid, Sort, Tree };

#[derive(Eq, PartialEq)]
pub(crate) enum CommitReference {
	Branch(String),
	Direct(Oid),
	Head,
	Tag(String),
}

impl CommitReference {
	pub(crate) fn slug(&self) -> String {
		use CommitReference::*;

		match *self {
			Branch(ref branch_name) => format!("branch/{}", branch_name),
			Direct(commit_id) => format!("commit/{}", commit_id),
			Head => "head".to_string(),
			Tag(ref tag_name) => format!("tag/{}", tag_name),
		}
	}
}

impl fmt::Display for CommitReference {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		use CommitReference::*;

		match *self {
			Branch(ref branch_name) => write!(f, "{}", branch_name),
			Direct(id) => write!(f, "{}", id),
			Head => write!(f, "HEAD"),
			Tag(ref tag_name) => write!(f, "{}", tag_name),
		}
	}
}

pub(crate) struct Git {
	path: PathBuf,
}

impl Git {
	pub(crate) fn open(path: &std::path::Path) -> Result<Git> {
		match fs::read_dir(path) {
			Ok(_) => Ok(Git { path: path.to_path_buf() }),
			Err(e) => Err(Error::InvalidGitRoot(e)),
		}
	}

	pub(crate) fn find_repository_by_name(&self, name: &str) -> Result<Repository> {
		// Scanning the repository iterator, rather than just concatenating the name onto the git.root,
		// is important because the iterator implements filtering and hiding.
		for repo in self.repositories()? {
			let repo = repo?;

			if repo.name()? == name {
				return Ok(repo);
			}
		}

		Err(Error::RepositoryNotFound(name.to_string()))
	}

	pub(crate) fn repositories(&self) -> Result<RepositoryIterator> {
		Ok(RepositoryIterator {
			directory_iterator: fs::read_dir(&self.path)?,
		})
	}
}

pub(crate) struct RepositoryIterator {
	directory_iterator: fs::ReadDir,
}

impl Iterator for RepositoryIterator {
	type Item = Result<Repository>;

	fn next(&mut self) -> Option<Result<Repository>> {
		let repository = loop {
			let path =
				match self.directory_iterator.next()? {
					Ok(directory_entry) => directory_entry.path(),
					Err(e) => return Some(Err(e.into())),
				};

			// Repositories have to be directories
			if !path.is_dir() {
				continue;
			}

			// We only consider bare repositories, i.e. `foo.git`, not `foo/.git`
			if path.extension() != Some(OsStr::new("git")) {
				continue;
			}

			// We can hide a repository if it has a file called `gitten-hide-this-repository` at the root.
			//
			// THIS IS NOT A SECURITY FEATURE. DO NOT RELY ON THIS TO HIDE ENCRYPTION KEYS, TRADE SECRETS,
			// PII, OR OTHER SENSITIVE INFORMATION.
			let hide_path = path.join("gitten-hide-this-repository");
			if hide_path.is_file() {
				tracing::debug!("Hiding repository {}", path.display());
				continue;
			}

			break Repository::open(path);
		};

		match repository {
			Ok(repository) => Some(Ok(repository)),
			Err(e) => Some(Err(e.into())),
		}
	}
}

pub(crate) trait RepositoryExtensions {
	fn find_blob_name_by_path(&self, commit_reference: &CommitReference, blob_path: &str) -> Result<String>;

	fn find_blob_text_by_path(&self, commit_reference: &CommitReference, path: &str) -> Result<String>;

	fn find_tree_name_by_path(&self, commit_reference: &CommitReference, tree_path: &str) -> Result<String>;

	fn list_branches(&self) -> Result<Vec<String>>;

	fn list_commit_history(&self, from_head: &CommitReference, page_size: usize, page: usize) -> Result<Vec<Commit>>;

	fn list_tags(&self) -> Result<Vec<String>>;

	fn list_tree_by_commit(&self, commit_reference: &CommitReference) -> Result<Vec<GitObjectMetadata>>;

	fn list_tree_by_path(&self, commit_reference: &CommitReference, tree_path: &str) -> Result<Vec<GitObjectMetadata>>;

	fn list_tree(&self, commit: &CommitReference, tree: &Tree, root: &str) -> Result<Vec<GitObjectMetadata>>;

	fn name(&self) -> Result<String>;

	fn resolve_commit_reference(&self, commit: &CommitReference) -> Result<Oid>;
}

impl RepositoryExtensions for Repository {
	fn find_blob_name_by_path(&self, commit_reference: &CommitReference, blob_path: &str) -> Result<String> {
		let commit_oid = self.resolve_commit_reference(commit_reference)?;
		let commit = self.find_commit(commit_oid)?;
		let commit_tree = commit.tree()?;
		let entry = commit_tree.get_path(Path::new(blob_path))?;

		match entry.kind() {
			Some(ObjectType::Blob) => entry.name().map(|s| s.to_string()).ok_or(Error::UnnamedTreeEntry(entry.id())),
			Some(k) => Err(Error::UnexpectedObjectType(k)),
			None => Err(Error::ObjectNotFoundByPath(blob_path.to_string())),
		}
	}

	fn find_blob_text_by_path(&self, commit_reference: &CommitReference, blob_path: &str) -> Result<String> {
		let commit_oid = self.resolve_commit_reference(commit_reference)?;
		let commit = self.find_commit(commit_oid)?;
		let commit_tree = commit.tree()?;
		let entry = commit_tree.get_path(Path::new(blob_path))?;
		let object = entry.to_object(self)?;

		if let Some(blob) = object.as_blob() {
			let content = blob.content();
			let text = String::from_utf8(content.to_vec())
				.map_err(Error::NonUtf8Blob)?;
			Ok(text)
		} else if let Some(kind) = object.kind() {
			Err(Error::UnexpectedObjectType(kind))
		} else {
			Err(Error::UntypedTreeEntry(entry.id()))
		}
	}

	fn find_tree_name_by_path(&self, commit_reference: &CommitReference, tree_path: &str) -> Result<String> {
		let commit_oid = self.resolve_commit_reference(commit_reference)?;
		let commit = self.find_commit(commit_oid)?;
		let commit_tree = commit.tree()?;
		let entry = commit_tree.get_path(Path::new(tree_path))?;

		match entry.kind() {
			Some(ObjectType::Tree) => entry.name().map(|s| s.to_string()).ok_or(Error::UnnamedTreeEntry(entry.id())),
			Some(k) => Err(Error::UnexpectedObjectType(k)),
			None => Err(Error::ObjectNotFoundByPath(tree_path.to_string())),
		}
	}

	fn list_branches(&self) -> Result<Vec<String>> {
		let branches = self.references()?
			.map(|reference| {
				let reference = reference?;
				Ok(reference)
			})
			.collect::<Result<Vec<_>>>()?
			.into_iter()
			.filter(|reference| reference.is_branch())
			.map(|branch| {
				// shorthand because we don't want the `refs/heads/` part of the name
				let branch_name = branch.shorthand_bytes();
				let branch_name = String::from_utf8(branch_name.to_vec())
					.map_err(Error::NonUtf8BranchName)?;

				Ok(branch_name)
			})
			.collect::<Result<_>>()?;

		Ok(branches)
	}

	fn list_commit_history(&self, from_head: &CommitReference, page_size: usize, page: usize) -> Result<Vec<Commit>> {
		let commit_id = self.resolve_commit_reference(from_head)?;
		let mut revwalk = self.revwalk()?;

		revwalk.set_sorting(Sort::TOPOLOGICAL | Sort::TIME)?;
		revwalk.push(commit_id)?;

		let history = revwalk
			.skip(page_size * page)
			.take(page_size)
			.map(|commit_id| {
				let commit_id = commit_id?;
				let commit = self.find_commit(commit_id)?;
				Ok(commit)
			})
			.collect::<Result<_>>()?;

		Ok(history)
	}

	fn list_tags(&self) -> Result<Vec<String>> {
		let tags = self.references()?
			.map(|reference| {
				let reference = reference?;
				Ok(reference)
			})
			.collect::<Result<Vec<_>>>()?
			.into_iter()
			.filter(|reference| reference.is_tag())
			.map(|tag| {
				let tag_name = tag.shorthand_bytes();
				let tag_name = String::from_utf8(tag_name.to_vec())
					.map_err(Error::NonUtf8TagName)?;

				Ok(tag_name)
			})
			.collect::<Result<_>>()?;

		Ok(tags)
	}

	fn list_tree_by_commit(&self, commit_reference: &CommitReference) -> Result<Vec<GitObjectMetadata>> {
		let commit_oid = self.resolve_commit_reference(commit_reference)?;
		let commit = self.find_commit(commit_oid)?;
		let commit_tree = commit.tree()?;
		self.list_tree(commit_reference, &commit_tree, "")
	}

	fn list_tree_by_path(&self, commit_reference: &CommitReference, tree_path: &str) -> Result<Vec<GitObjectMetadata>> {
		let commit_oid = self.resolve_commit_reference(commit_reference)?;
		let commit = self.find_commit(commit_oid)?;
		let commit_tree = commit.tree()?;
		let entry = commit_tree.get_path(Path::new(tree_path))?;
		let object = entry.to_object(self)?;

		if let Some(tree) = object.as_tree() {
			self.list_tree(commit_reference, tree, tree_path)
		} else if let Some(kind) = object.kind() {
			Err(Error::UnexpectedObjectType(kind))
		} else {
			Err(Error::UntypedTreeEntry(entry.id()))
		}
	}

	fn list_tree(&self, commit: &CommitReference, tree: &Tree, root: &str) -> Result<Vec<GitObjectMetadata>> {
		let repository_name = self.name()?;

		let list = tree.iter().map(|entry| {
			let name = entry
				.name()
				.ok_or(Error::UnnamedTreeEntry(entry.id()))?
				.to_string();

			let kind = entry
				.kind()
				.ok_or(Error::UntypedTreeEntry(entry.id()))?
				.try_into()?;

			let object_path = if root.is_empty() {
				name.clone()
			} else {
				format!("{}/{}", root, name)
			};

			let commit_path = format!("/repository/{}/{}", repository_name, commit.slug());

			let link = match kind {
				GitObjectKind::Blob => format!("{}/blob/{}", commit_path, object_path),
				GitObjectKind::Tree => format!("{}/tree/{}", commit_path, object_path),
				_ => return Err(Error::UnexpectedObjectType(kind.into())),
			};

			Ok(GitObjectMetadata {
				repository_name: repository_name.clone(),
				id: entry.id().to_string(),
				link,
				path: object_path,
				name,
				kind,
			})
		}).collect::<Result<_>>()?;

		Ok(list)
	}

	fn name(&self) -> Result<String> {
		let raw_name =
			if self.is_bare() {
				let Some(file_stem) = self.path().file_stem() else {
					return Err(Error::CannotDetermineRepositoryName(self.path().to_path_buf()));
				};

				file_stem
			} else {
				let Some(parent) = self.path().parent() else {
					return Err(Error::CannotDetermineRepositoryName(self.path().to_path_buf()));
				};

				let Some(file_name) = parent.file_name() else {
					return Err(Error::CannotDetermineRepositoryName(self.path().to_path_buf()));
				};

				file_name
			};

		let Some(name) = raw_name.to_str() else {
			return Err(Error::CannotDetermineRepositoryName(self.path().to_path_buf()));
		};

		Ok(name.to_string())
	}

	fn resolve_commit_reference(&self, commit_reference: &CommitReference) -> Result<Oid> {
		let id = match commit_reference {
			CommitReference::Branch(branch_name) => self.refname_to_id(&format!("refs/heads/{}", branch_name))?,
			CommitReference::Direct(id) => *id,
			CommitReference::Head => self.refname_to_id("HEAD")?,
			CommitReference::Tag(tag_name) => {
				let id = self.refname_to_id(&format!("refs/tags/{}", tag_name))?;

				// If the tag is a full tag object, we need to peel it to find whatever it's referring to
				// (hopefully a commit)
				if let Ok(full_tag) = self.find_tag(id) {
					full_tag.peel()?.id()
				} else {
					id
				}
			},
		};
		Ok(id)
	}
}

#[derive(Clone, Debug, Serialize)]
pub(crate) struct GitObjectMetadata {
	pub(crate) repository_name: String,
	pub(crate) id: String,
	pub(crate) link: String,
	pub(crate) path: String,
	pub(crate) name: String,
	pub(crate) kind: GitObjectKind,
}

impl fmt::Display for GitObjectMetadata {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "{} {}", self.kind, self.name)
	}
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub(crate) enum GitObjectKind {
	Blob,
	Commit,
	Tag,
	Tree,
}

impl TryFrom<ObjectType> for GitObjectKind {
	type Error = Error;

	fn try_from(t: ObjectType) -> Result<GitObjectKind> {
		match t {
			ObjectType::Blob => Ok(GitObjectKind::Blob),
			ObjectType::Commit => Ok(GitObjectKind::Commit),
			ObjectType::Tag => Ok(GitObjectKind::Tag),
			ObjectType::Tree => Ok(GitObjectKind::Tree),
			_ => Err(Error::UnexpectedObjectType(t)),
		}
	}
}

impl From<GitObjectKind> for ObjectType {
	fn from(k: GitObjectKind) -> ObjectType {
		match k {
			GitObjectKind::Blob => ObjectType::Blob,
			GitObjectKind::Commit => ObjectType::Commit,
			GitObjectKind::Tag => ObjectType::Tag,
			GitObjectKind::Tree => ObjectType::Tree,
		}
	}
}

impl fmt::Display for GitObjectKind {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		use GitObjectKind::*;

		match *self {
			Blob => write!(f, "blob"),
			Commit => write!(f, "commit"),
			Tag => write!(f, "tag"),
			Tree => write!(f, "tree"),
		}
	}
}