// This file is part of radicle-surf // // // Copyright (C) 2019-2020 The Radicle Team // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License version 3 or // later as published by the Free Software Foundation. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . //! Represents git object type 'tree', i.e. like directory entries in Unix. //! See git [doc](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects) for more details. use std::path::Path; #[cfg(feature = "serde")] use serde::{ ser::{SerializeStruct as _, Serializer}, Serialize, }; use crate::{ file_system::{directory, Directory}, git::{self, Repository}, source::{commit, object::Error}, }; /// Result of a directory listing, carries other trees and blobs. pub struct Tree { pub directory: Directory, pub commit: Option, /// Entries listed in that tree result. pub entries: Vec, } impl Tree { /// Retrieve the [`Tree`] for the given `revision` and directory `prefix`. /// /// # Errors /// /// Will return [`Error`] if any of the surf interactions fail. pub fn new(repo: &Repository, revision: &R, prefix: Option<&P>) -> Result where P: AsRef, R: git::Revision, { let prefix = prefix.map(|p| p.as_ref()); let prefix_dir = match prefix { None => repo.root_dir(revision)?, Some(path) => repo .root_dir(revision)? .find_directory(&path, repo)? .ok_or_else(|| Error::PathNotFound(path.to_path_buf()))?, }; let mut entries = prefix_dir .entries(repo)? .entries() .cloned() .map(TreeEntry::from) .collect::>(); entries.sort(); let last_commit = if prefix.is_none() { let history = repo.history(revision)?; Some(commit::Header::from(history.head())) } else { None }; Ok(Tree { entries, directory: prefix_dir, commit: last_commit, }) } } #[cfg(feature = "serde")] impl Serialize for Tree { fn serialize(&self, serializer: S) -> Result where S: Serializer, { const FIELDS: usize = 4; let mut state = serializer.serialize_struct("Tree", FIELDS)?; state.serialize_field("entries", &self.entries)?; state.serialize_field("lastCommit", &self.commit)?; state.serialize_field("name", &self.directory.name())?; state.serialize_field("path", &self.directory.location())?; state.end() } } /// Entry in a Tree result. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] pub struct TreeEntry { pub entry: directory::Entry, } impl From for TreeEntry { fn from(entry: directory::Entry) -> Self { Self { entry } } } impl From for directory::Entry { fn from(TreeEntry { entry }: TreeEntry) -> Self { entry } } #[cfg(feature = "serde")] impl Serialize for TreeEntry { fn serialize(&self, serializer: S) -> Result where S: Serializer, { const FIELDS: usize = 4; let mut state = serializer.serialize_struct("TreeEntry", FIELDS)?; state.serialize_field("path", &self.entry.location())?; state.serialize_field("name", &self.entry.name())?; state.serialize_field("lastCommit", &None::)?; state.serialize_field( "kind", match self.entry { directory::Entry::File(_) => "blob", directory::Entry::Directory(_) => "directory", }, )?; state.end() } }