aboutsummaryrefslogtreecommitdiffstats
path: root/src/web/generate
diff options
context:
space:
mode:
Diffstat (limited to 'src/web/generate')
-rw-r--r--src/web/generate/mod.rs518
-rw-r--r--src/web/generate/templates.rs44
2 files changed, 433 insertions, 129 deletions
diff --git a/src/web/generate/mod.rs b/src/web/generate/mod.rs
index 06bab17..e68bddf 100644
--- a/src/web/generate/mod.rs
+++ b/src/web/generate/mod.rs
@@ -1,144 +1,353 @@
-// Back - An extremely simple git bug visualization system. Inspired by TVL's
-// panettone.
-//
-// Copyright (C) 2025 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-// SPDX-License-Identifier: AGPL-3.0-or-later
-//
-// This file is part of Back.
-//
-// You should have received a copy of the License along with this program.
-// If not, see <https://www.gnu.org/licenses/agpl.txt>.
-
use std::{fs, path::Path};
-use gix::hash::Prefix;
-use log::info;
-use rinja::Template;
-use url::Url;
-
-use crate::{
- config::BackConfig,
- error,
- git_bug::{
- dag::issues_from_repository,
- issue::{CollapsedIssue, Status},
+use git_bug::{
+ entities::{
+ identity::Identity,
+ issue::{
+ Issue, data::status::Status, query::MatchKeyValue, snapshot::timeline::IssueTimeline,
+ },
+ },
+ query::{Matcher, Query},
+ replica::{
+ Replica,
+ entity::{
+ Entity,
+ id::prefix::IdPrefix,
+ snapshot::{
+ Snapshot,
+ timeline::{Timeline, history_step::HistoryStep},
+ },
+ },
},
};
+use log::info;
+use templates::to_markdown;
+use vy::{IntoHtml, a, div, footer, form, h1, header, input, li, main, nav, ol, p, span};
+
+use crate::{config::BackConfig, error, web::generate::templates::make_page};
-#[derive(Template)]
-#[template(path = "./issues.html")]
-struct IssuesTemplate {
- wanted_status: Status,
- counter_status: Status,
- issues: Vec<CollapsedIssue>,
+pub(crate) mod templates;
- /// The path to the repository
- repo_path: String,
+fn get_other_status(current: Status) -> Status {
+ match current {
+ Status::Open => Status::Closed,
+ Status::Closed => Status::Open,
+ }
+}
+
+fn set_query_status(
+ mut root_matcher: Matcher<Snapshot<Issue>>,
+ status: Status,
+) -> Matcher<Snapshot<Issue>> {
+ fn change_status(matcher: &mut Matcher<Snapshot<Issue>>, status: Status) {
+ match matcher {
+ Matcher::Or { lhs, rhs } | Matcher::And { lhs, rhs } => {
+ change_status(lhs, status);
+ change_status(rhs, status);
+ }
+ Matcher::Match { key_value } => {
+ if let MatchKeyValue::Status(found_status) = key_value {
+ *found_status = status;
+ }
+ }
+ }
+ }
- /// The URL to `back`'s source code
- source_code_repository_url: Url,
+ change_status(&mut root_matcher, status);
+ root_matcher
}
-pub fn issues(
+
+#[allow(clippy::too_many_lines)]
+pub(crate) fn issues(
config: &BackConfig,
- wanted_status: Status,
- counter_status: Status,
repo_path: &Path,
+ replica: &Replica,
+ query: &Query<Snapshot<Issue>>,
) -> error::Result<String> {
- let repository = config
- .repositories()?
- .get(repo_path)?
- .open(&config.scan_path)?;
-
- let mut issue_list = issues_from_repository(&repository.to_thread_local())?
+ let mut issue_list = replica
+ .get_all_with_query::<Issue>(query)?
+ .collect::<Result<Result<Vec<Issue>, _>, _>>()??
.into_iter()
- .map(|issue| issue.collapse())
- .filter(|issue| issue.status == wanted_status)
- .collect::<Vec<CollapsedIssue>>();
+ .map(|i| i.snapshot())
+ .map(|i| -> error::Result<_> {
+ let author = i.author();
+ Ok((i, author.resolve(replica)?.snapshot()))
+ })
+ .collect::<error::Result<Vec<_>>>()?;
// Sort by date descending.
// SAFETY:
// The time stamp is only used for sorting, so a malicious attacker could only affect the issue
// sorting.
- issue_list.sort_by_key(|issue| unsafe { issue.timestamp.to_unsafe() });
- issue_list.reverse();
+ issue_list.sort_by_key(|(issue, _)| unsafe {
+ issue
+ .timeline()
+ .history()
+ .first()
+ .expect("Is some")
+ .at()
+ .to_unsafe()
+ });
- Ok(IssuesTemplate {
- wanted_status,
- counter_status,
- source_code_repository_url: config.source_code_repository_url.clone(),
- issues: issue_list,
- repo_path: repo_path.display().to_string(),
- }
- .render()
- .expect("This should always work"))
-}
+ let root_matcher = query.as_matcher().unwrap_or(&Matcher::Match {
+ key_value: MatchKeyValue::Status(Status::Open),
+ });
+
+ let status = {
+ fn find_status(matcher: &Matcher<Snapshot<Issue>>) -> Option<Status> {
+ fn merge(status1: Option<Status>, status2: Option<Status>) -> Option<Status> {
+ match (status1, status2) {
+ (None, None) => None,
+ (None, Some(b)) => Some(b),
+ #[allow(clippy::match_same_arms)]
+ (Some(a), None) => Some(a),
+ // TODO(@bpeetz): Should we warn the user somehow? <2025-05-28>
+ (Some(a), Some(_)) => Some(a),
+ }
+ }
+
+ match matcher {
+ Matcher::Or { lhs, rhs } | Matcher::And { lhs, rhs } => {
+ merge(find_status(lhs), find_status(rhs))
+ }
+ Matcher::Match { key_value } => match key_value {
+ MatchKeyValue::Status(status) => Some(*status),
+ _ => None,
+ },
+ }
+ }
-use crate::git_bug::format::HtmlString;
-#[derive(Template)]
-#[template(path = "./issue.html")]
-struct IssueTemplate {
- issue: CollapsedIssue,
+ find_status(root_matcher)
+ };
- /// The path to the repository
- repo_path: String,
+ // TODO(@bpeetz): Be less verbose. <2025-06-06>
+ let query_string = query.to_string();
- /// The URL to `back`'s source code
- source_code_repository_url: Url,
+ Ok(make_page(
+ (
+ header!(h1!((
+ status.map_or(String::new(), |a| a.to_string()),
+ " Issues"
+ ))),
+ main!(
+ div!(
+ class = "issue-links",
+ if let Some(status) = status {
+ a!(
+ href = format!(
+ "/{}/issues/?query={}",
+ repo_path.display(),
+ Query::from_matcher(set_query_status(
+ root_matcher.clone(),
+ get_other_status(status)
+ ))
+ .to_string()
+ ),
+ "View ",
+ get_other_status(status).to_string(),
+ " issues"
+ )
+ },
+ a!(href = "/", "View repos",),
+ form!(
+ class = "issue-search",
+ method = "get",
+ input!(
+ name = "query",
+ value = &query_string,
+ title = "Issue search query",
+ "type" = "search",
+ placeholder = "status:open title:\"Test\"",
+ size = query_string.chars().count().clamp(20, 40),
+ ),
+ input!(
+ class = "sr-only",
+ "type" = "submit",
+ value = "Search Issues"
+ )
+ )
+ ),
+ ol!(
+ class = "issue-list",
+ issue_list.iter().map(|(issue, identity)| {
+ li!(a!(
+ href = format!("/{}/issue/{}", repo_path.display(), issue.id()),
+ p!(span!(
+ class = "issue-subject",
+ to_markdown(issue.title(), true)
+ )),
+ span!(
+ class = "issue-number",
+ issue.id().as_id().shorten().to_string()
+ ),
+ " ",
+ display_issue_open(identity, issue.timeline()),
+ if !issue.comments().is_empty() {
+ span!(
+ class = "comment-count",
+ " - ",
+ issue.comments().len(),
+ " ",
+ {
+ if issue.comments().len() > 1 {
+ "comments"
+ } else {
+ "comment"
+ }
+ }
+ )
+ }
+ ))
+ })
+ )
+ ),
+ footer!(nav!(a!(
+ href = config.source_code_repository_url.to_string(),
+ "Source Code"
+ ))),
+ ),
+ "issue list page",
+ None,
+ )
+ .into_string())
}
-pub fn issue(config: &BackConfig, repo_path: &Path, prefix: Prefix) -> error::Result<String> {
- let repository = config
+
+pub(crate) fn issue(
+ config: &BackConfig,
+ repo_path: &Path,
+ prefix: IdPrefix,
+) -> error::Result<String> {
+ let replica = config
.repositories()?
.get(repo_path)?
- .open(&config.scan_path)?
- .to_thread_local();
+ .open(&config.scan_path)?;
- let maybe_issue = issues_from_repository(&repository)?
- .into_iter()
- .map(|val| val.collapse())
- .find(|issue| issue.id.to_string().starts_with(&prefix.to_string()));
+ let issue = replica
+ .get(prefix.resolve::<Issue>(replica.repo()).map_err(|err| {
+ error::Error::IssuesPrefixMissing {
+ prefix: Box::new(prefix),
+ err,
+ }
+ })?)?
+ .snapshot();
- match maybe_issue {
- Some(issue) => Ok(IssueTemplate {
- issue,
- repo_path: repo_path.display().to_string(),
- source_code_repository_url: config.source_code_repository_url.clone(),
- }
- .render()
- .expect("This should always work")),
- None => Err(error::Error::IssuesPrefixMissing { prefix }),
- }
-}
+ let identity = issue.author().resolve(&replica)?.snapshot();
-#[derive(Template)]
-#[template(path = "./repos.html")]
-struct ReposTemplate {
- repos: Vec<RepoValue>,
+ Ok(make_page(
+ div!(
+ class = "content",
+ nav!(
+ a!(
+ href = format!("/{}/issues/?query=status:open", repo_path.display()),
+ "Open Issues"
+ ),
+ a!(
+ href = format!("/{}/issues/?query=status:closed", repo_path.display()),
+ "Closed Issues"
+ ),
+ ),
+ header!(
+ h1!(to_markdown(issue.title(), true)),
+ div!(
+ class = "issue-number",
+ issue.id().as_id().shorten().to_string()
+ )
+ ),
+ main!(
+ div!(
+ class = "issue-info",
+ display_issue_open(&identity, issue.timeline())
+ ),
+ to_markdown(issue.body(), false),
+ if !issue.comments().is_empty() {
+ ol!(
+ class = "issue-history",
+ issue
+ .comments()
+ .into_iter()
+ .map(|comment| {
+ Ok(li!(
+ class = "comment",
+ id = comment.combined_id.shorten().to_string(),
+ to_markdown(&comment.message, false),
+ p!(
+ class = "comment-info",
+ span!(
+ class = "user-name",
+ comment
+ .author
+ .resolve(&replica)?
+ .snapshot()
+ .name()
+ .to_owned(),
+ " at ",
+ comment.timestamp.to_string()
+ )
+ )
+ ))
+ })
+ .collect::<error::Result<Vec<_>>>()?
+ )
+ }
+ ),
+ footer!(nav!(a!(
+ href = config.source_code_repository_url.to_string(),
+ "Source code"
+ ),))
+ ),
+ "issue detail page",
+ Some(format!("{} | Back", issue.title()).as_str()),
+ )
+ .into_string())
+}
- /// The URL to `back`'s source code
- source_code_repository_url: Url,
+fn display_issue_open(
+ identity: &Snapshot<Identity>,
+ issue_timeline: &IssueTimeline,
+) -> impl IntoHtml {
+ span!(
+ class = "created-by-at",
+ "Opened by ",
+ span!(class = "user-name", identity.name()),
+ " ",
+ identity
+ .email()
+ .map(|email| span!(class = "user-email", "<", email, "> ",)),
+ "at ",
+ span!(class = "timestamp", {
+ {
+ issue_timeline
+ .history()
+ .last()
+ .expect("Exists")
+ .at()
+ .to_string()
+ }
+ })
+ )
}
+
struct RepoValue {
description: String,
owner: String,
path: String,
}
-pub fn repos(config: &BackConfig) -> error::Result<String> {
+
+pub(crate) fn repos(config: &BackConfig) -> error::Result<String> {
let repos: Vec<RepoValue> = config
.repositories()?
.iter()
.filter_map(|raw_repo| match raw_repo.open(&config.scan_path) {
- Ok(repo) => {
- let repo = repo.to_thread_local();
- let git_config = repo.config_snapshot();
+ Ok(replica) => {
+ let git_config = replica.repo().config_snapshot();
let path = raw_repo.path().to_string_lossy().to_string();
let owner = git_config
.string("cgit.owner")
- .map(|v| v.to_string())
- .unwrap_or("<No owner>".to_owned());
+ .map_or("<No owner>".to_owned(), |v| v.to_string());
- let description = fs::read_to_string(repo.git_dir().join("description"))
+ let description = fs::read_to_string(replica.repo().git_dir().join("description"))
.unwrap_or("<No description>".to_owned());
Some(RepoValue {
@@ -157,73 +366,124 @@ pub fn repos(config: &BackConfig) -> error::Result<String> {
})
.collect();
- Ok(ReposTemplate {
- repos,
- source_code_repository_url: config.source_code_repository_url.clone(),
- }
- .render()
- .expect("this should work"))
+ Ok(make_page(
+ div!(
+ class = "content",
+ header!(h1!("Repositiories")),
+ main!(
+ div!(
+ class = "issue-links",
+ // TODO(@bpeetz): Add a search. <2025-05-21>
+ ),
+ if !repos.is_empty() {
+ ol!(
+ class = "issue-list",
+ repos.into_iter().map(|repo| {
+ li!(a!(
+ href = format!("/{}/issues/?query=status:open", repo.path),
+ p!(span!(class = "issue-subject", repo.path)),
+ span!(
+ class = "created-by-at",
+ span!(class = "timestamp", repo.description),
+ " - ",
+ span!(class = "user-name", repo.owner)
+ )
+ ))
+ })
+ )
+ }
+ ),
+ footer!(nav!(a!(
+ href = config.source_code_repository_url.to_string(),
+ "Source Code"
+ ))),
+ ),
+ "repository listing page",
+ Some("Repos | Back"),
+ )
+ .into_string())
}
-pub fn feed(config: &BackConfig, repo_path: &Path) -> error::Result<String> {
+pub(crate) fn feed(config: &BackConfig, repo_path: &Path) -> error::Result<String> {
use rss::{ChannelBuilder, Item, ItemBuilder};
- let repository = config
+ let replica = config
.repositories()?
.get(repo_path)?
- .open(&config.scan_path)?
- .to_thread_local();
+ .open(&config.scan_path)?;
- let issues: Vec<CollapsedIssue> = issues_from_repository(&repository)?
+ let issues: Vec<Snapshot<Issue>> = replica
+ .get_all::<Issue>()?
+ .collect::<Result<Result<Vec<Issue>, _>, _>>()??
.into_iter()
- .map(|issue| issue.collapse())
- .collect();
+ .map(|i| i.snapshot())
+ .collect::<Vec<_>>();
// Collect all Items as rss items
let mut items: Vec<Item> = issues
.iter()
- .map(|issue| {
- ItemBuilder::default()
- .title(issue.title.to_string())
- .author(issue.author.to_string())
- .description(issue.message.to_string())
- .pub_date(issue.timestamp.to_string())
+ .map(|issue| -> error::Result<_> {
+ Ok(ItemBuilder::default()
+ .title(issue.title().to_string())
+ .author(
+ replica
+ .get(issue.author().id())?
+ .snapshot()
+ .name()
+ .to_owned(),
+ )
+ .description(issue.body().to_string())
+ .pub_date(
+ issue
+ .timeline()
+ .history()
+ .last()
+ .expect("Exists")
+ .at()
+ .to_string(),
+ )
.link(format!(
"/{}/{}/issue/{}",
repo_path.display(),
&config.root_url,
- issue.id
+ issue.id()
))
- .build()
+ .build())
})
- .collect();
+ .collect::<error::Result<Vec<Item>>>()?;
// Append all comments after converting them to rss items
items.extend(
issues
.iter()
- .filter(|issue| !issue.comments.is_empty())
+ .filter(|issue| !issue.comments().is_empty())
.flat_map(|issue| {
issue
- .comments
+ .comments()
.iter()
- .map(|comment| {
- ItemBuilder::default()
- .title(issue.title.to_string())
- .author(comment.author.to_string())
+ .map(|comment| -> error::Result<_> {
+ Ok(ItemBuilder::default()
+ .title(issue.title().to_string())
+ .author(
+ replica
+ .get(comment.author.id())?
+ .snapshot()
+ .name()
+ .to_owned(),
+ )
.description(comment.message.to_string())
.pub_date(comment.timestamp.to_string())
.link(format!(
"/{}/{}/issue/{}",
repo_path.display(),
&config.root_url,
- issue.id
+ comment.combined_id.shorten()
))
- .build()
+ .build())
})
- .collect::<Vec<Item>>()
+ .collect::<Vec<_>>()
})
- .collect::<Vec<Item>>(),
+ .collect::<error::Result<Vec<Item>>>()?,
);
let channel = ChannelBuilder::default()
diff --git a/src/web/generate/templates.rs b/src/web/generate/templates.rs
new file mode 100644
index 0000000..693b862
--- /dev/null
+++ b/src/web/generate/templates.rs
@@ -0,0 +1,44 @@
+use vy::{DOCTYPE, IntoHtml, PreEscaped, body, div, head, html, link, meta, title};
+
+pub(crate) fn make_page(
+ content: impl IntoHtml,
+ description: &str,
+ title: Option<&str>,
+) -> impl IntoHtml {
+ (
+ DOCTYPE,
+ html!(
+ lang = "en",
+ head!(
+ title!(title.unwrap_or("Back")),
+ link!(rel = "icon", href = "/favicon.ico"),
+ link!(rel = "stylesheet", "type" = "text/css", href = "/style.css"),
+ meta!(charset = "UTF-8"),
+ meta!(
+ name = "viewport",
+ content = "width=device-width,initial-scale=1"
+ ),
+ meta!(name = "description", content = description),
+ ),
+ body!(div!(class = "content", content))
+ ),
+ )
+}
+
+pub(super) fn to_markdown(input: &str, is_title: bool) -> PreEscaped<String> {
+ let markdown = markdown::to_html(input.trim());
+
+ // If the markdown contains only one line line, assuming that it is a title is okay.
+ if input.lines().count() == 1 && markdown.starts_with("<p>") && is_title {
+ PreEscaped(
+ markdown
+ .strip_prefix("<p>")
+ .expect("We checked")
+ .strip_suffix("</p>")
+ .expect("markdown crate produces no invalid html")
+ .to_owned(),
+ )
+ } else {
+ PreEscaped(markdown)
+ }
+}
generated by cgit v1.3.1 (git 2.54.0) at 2026-06-27 17:09:30 +0000