bile

a simple self-hosted git server

git clone https://git.wayver.dev/bile

README | tree | log | refs

---

src/git/core.rs@32c6bed79b26b918b19bcaa6d2f5eaf797bbeb92

raw

---

Date	Commit Message	Author	Files	+	-
2026-02-23 00:23	make it so README.md is detected as a valid readme	wayverd	1	1	1
...

---

use std::path::Path;

use git2::{Reference, Time};
use syntect::parsing::SyntaxSet;

use crate::{error::Context as _, error::Result, git::Repository, http::extractor::Ref};

impl Repository {
    #[must_use]
    pub(crate) fn description(&self) -> String {
        let content = std::fs::read_to_string(self.path().join("description")).unwrap_or_default();

        let first = content.lines().next().unwrap_or_default();

        first.to_string()
    }

    #[tracing::instrument(skip_all)]
    pub(crate) fn head(&self) -> Result<Reference<'_>> {
        let head = self.inner.head()?;

        Ok(head)
    }

    #[tracing::instrument(skip_all)]
    pub(crate) fn is_empty(&self) -> Result<bool> {
        Ok(self.inner.is_empty()?)
    }

    #[must_use]
    pub(crate) fn is_shallow(&self) -> bool {
        self.inner.is_shallow()
    }

    #[tracing::instrument(skip_all)]
    pub(crate) fn last_modified(&self) -> Result<Time> {
        let head = self.head()?;
        let commit = head.peel_to_commit()?;
        let time = commit.committer().when();

        Ok(time)
    }

    pub(crate) fn name(&self) -> Option<&str> {
        self.inner
            .workdir()
            // use the path for bare repositories
            .unwrap_or_else(|| self.inner.path())
            .file_name()
            .and_then(std::ffi::OsStr::to_str)
    }

    #[must_use]
    pub(crate) fn owner(&self) -> String {
        self.inner
            .config()
            .and_then(|config| config.get_string("gitweb.owner"))
            .unwrap_or_default()
    }

    #[must_use]
    pub(crate) fn path(&self) -> &Path {
        self.inner.path()
    }

    #[must_use]
    pub(crate) fn readme(&self, syntaxes: &SyntaxSet) -> String {
        use askama::filters::Escaper as _;

        enum ReadmeFormat {
            Plaintext,
            Html,
            Markdown,
        }

        let mut format = ReadmeFormat::Plaintext;

        self.inner
            .revparse_single("HEAD:readme")
            .or_else(|_| self.inner.revparse_single("HEAD:README.txt"))
            .or_else(|_| self.inner.revparse_single("HEAD:readme.txt"))
            .or_else(|_| self.inner.revparse_single("HEAD:README.txt"))
            .or_else(|_| {
                format = ReadmeFormat::Markdown;
                self.inner.revparse_single("HEAD:readme.md")
            })
            .or_else(|_| self.inner.revparse_single("HEAD:README.md"))
            .or_else(|_| self.inner.revparse_single("HEAD:readme.mdown"))
            .or_else(|_| self.inner.revparse_single("HEAD:README.mdown"))
            .or_else(|_| self.inner.revparse_single("HEAD:readme.markdown"))
            .or_else(|_| self.inner.revparse_single("HEAD:README.markdown"))
            .or_else(|_| {
                format = ReadmeFormat::Html;
                self.inner.revparse_single("HEAD:readme.html")
            })
            .or_else(|_| self.inner.revparse_single("HEAD:README.html"))
            .or_else(|_| self.inner.revparse_single("HEAD:readme.htm"))
            .or_else(|_| self.inner.revparse_single("HEAD:README.htm"))
            .ok()
            .and_then(|readme| readme.into_blob().ok())
            .map(|blob| {
                let text = str::from_utf8(blob.content()).unwrap_or_default();

                // render the file contents to HTML
                match format {
                    // render plaintext as preformatted text
                    ReadmeFormat::Plaintext => {
                        let mut output = "<pre>".to_string();
                        if let Err(err) = askama::filters::Html.write_escaped_str(&mut output, text)
                        {
                            tracing::error!(err=?err, "failed to write escaped plaintext readme");
                        }
                        output.push_str("</pre>");
                        output
                    }
                    // already is HTML
                    ReadmeFormat::Html => text.to_string(),
                    // render Markdown to HTML
                    ReadmeFormat::Markdown => crate::utils::markdown::render(syntaxes, text),
                }
            })
            .unwrap_or_default()
    }

    #[tracing::instrument(skip_all)]
    pub(crate) fn ref_or_head_shorthand(&self, r#ref: Option<&Ref>) -> Result<String> {
        let head = self.head()?;

        let spec = r#ref
            .map(|r| r.0.clone())
            .or_else(move || head.shorthand().map(str::to_string))
            .context("failed to get repo ref spec")?;

        Ok(spec)
    }
}