aboutsummaryrefslogtreecommitdiffstats
path: root/src/web
diff options
context:
space:
mode:
Diffstat (limited to 'src/web')
-rw-r--r--src/web/generate/mod.rs518
-rw-r--r--src/web/generate/templates.rs44
-rw-r--r--src/web/mod.rs123
-rw-r--r--src/web/responses.rs135
4 files changed, 644 insertions, 176 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)
+ }
+}
diff --git a/src/web/mod.rs b/src/web/mod.rs
index 8e2e9b0..0f9835a 100644
--- a/src/web/mod.rs
+++ b/src/web/mod.rs
@@ -9,21 +9,28 @@
// 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::{convert::Infallible, net::SocketAddr, path::PathBuf, sync::Arc};
+use std::{cell::OnceCell, convert::Infallible, net::SocketAddr, path::PathBuf, sync::Arc};
use bytes::Bytes;
+use git_bug::{
+ entities::issue::{Issue, data::status::Status, query::MatchKeyValue},
+ query::{Matcher, ParseMode, Query},
+ replica::entity::{id::prefix::IdPrefix, snapshot::Snapshot},
+};
use http_body_util::combinators::BoxBody;
use hyper::{Method, Request, Response, StatusCode, server::conn::http1, service::service_fn};
use hyper_util::rt::TokioIo;
-use log::{error, info};
-use responses::{html_response, html_response_status, html_response_status_content_type};
+use log::{error, info, warn};
+use responses::{html_response, html_response_status, html_response_status_content_type, redirect};
use tokio::net::TcpListener;
+use url::Url;
-use crate::{config::BackConfig, error, git_bug::issue::Status};
+use crate::{config::BackConfig, error};
mod generate;
mod responses;
+#[allow(clippy::unused_async, clippy::too_many_lines)]
async fn match_uri(
config: Arc<BackConfig>,
req: Request<hyper::body::Incoming>,
@@ -36,36 +43,69 @@ async fn match_uri(
}
let output = || -> Result<Response<BoxBody<Bytes, Infallible>>, error::Error> {
- match req.uri().path().trim_end_matches("/") {
+ match req.uri().path().trim_matches('/') {
"" => Ok(html_response(generate::repos(&config)?)),
- "/style.css" => Ok(responses::html_response_status_content_type(
+ "style.css" => Ok(html_response_status_content_type(
include_str!("../../assets/style.css"),
StatusCode::OK,
"text/css",
)),
+ "search.png" => Ok(html_response_status_content_type(
+ &include_bytes!("../../assets/search.png")[..],
+ StatusCode::OK,
+ "image/png",
+ )),
- path if path.ends_with("/issues/open") => {
- let repo_path = PathBuf::from(
- path.strip_suffix("/issues/open")
- .expect("This suffix exists")
- .strip_prefix("/")
- .expect("This also exists"),
- );
+ path if path.ends_with("/issues") => {
+ let repo_path =
+ PathBuf::from(path.strip_suffix("/issues").expect("This suffix exists"));
- let issues = generate::issues(&config, Status::Open, Status::Closed, &repo_path)?;
- Ok(html_response(issues))
- }
- path if path.ends_with("/issues/closed") => {
- let repo_path = PathBuf::from(
- path.strip_suffix("/issues/closed")
- .expect("This suffix exists")
- .strip_prefix("/")
- .expect("This also exists"),
- );
+ let replica = config
+ .repositories()?
+ .get(&repo_path)?
+ .open(&config.scan_path)?;
+
+ let query = {
+ // HACK(@bpeetz): We cannot use the uri directly, because that would require us
+ // to parse the query string. As such, we need to turn into into a url::Url,
+ // which provides this. Unfortunately, this re-parsing is the “officially”
+ // sanctioned way of doing this. <2025-05-28>
+ let url: Url = format!("https://{}{}", config.root_url, req.uri())
+ .parse()
+ .expect("Was a url before");
+
+ let mut query = OnceCell::new();
+ for (name, value) in url.query_pairs() {
+ if name == "query" && query.get().is_none() {
+ let val =
+ Query::from_continuous_str(&replica, &value, ParseMode::Relaxed)
+ .map_err(|err| error::Error::InvalidQuery {
+ err,
+ query: value.to_string(),
+ })?;
+ query.set(val).expect("We checked for initialized");
+ } else {
+ warn!("Unknown url query key: {name}");
+ }
+ }
+
+ query.take()
+ };
- let issues = generate::issues(&config, Status::Closed, Status::Open, &repo_path)?;
- Ok(html_response(issues))
+ if let Some(query) = query {
+ let issues = generate::issues(&config, &repo_path, &replica, &query)?;
+ Ok(html_response(issues))
+ } else {
+ let query = Query::<Snapshot<Issue>>::from_matcher(Matcher::Match {
+ key_value: MatchKeyValue::Status(Status::Open),
+ });
+ Ok(redirect(&format!(
+ "/{}/issues/?query={}",
+ repo_path.display(),
+ query
+ )))
+ }
}
path if path.ends_with("/issues/feed") => {
let repo_path = PathBuf::from(
@@ -87,22 +127,30 @@ async fn match_uri(
let (repo_path, prefix) = {
let split: Vec<&str> = path.split("/issue/").collect();
- let prefix =
- gix::hash::Prefix::from_hex(split[1]).map_err(error::Error::from)?;
+ let prefix = IdPrefix::from_hex_bytes(split[1].as_bytes()).map_err(|err| {
+ error::Error::IssuesPrefixParse {
+ prefix: split[1].to_owned(),
+ error: err,
+ }
+ })?;
- let repo_path =
- PathBuf::from(split[0].strip_prefix("/").expect("This prefix exists"));
+ let repo_path = PathBuf::from(split[0]);
(repo_path, prefix)
};
Ok(html_response(generate::issue(&config, &repo_path, prefix)?))
}
- other => Ok(responses::html_response_status_content_type(
- format!("'{}' not found", other),
- StatusCode::NOT_FOUND,
- "text/plain",
- )),
+ other if config.repositories()?.get(&PathBuf::from(other)).is_ok() => {
+ Ok(redirect(&format!("/{other}/issues/?query=status:open")))
+ }
+ other if config.repositories()?.get(&PathBuf::from(other)).is_err() => {
+ Err(error::Error::NotGitBug {
+ path: PathBuf::from(other),
+ })
+ }
+
+ other => Err(error::Error::NotFound(PathBuf::from(other))),
}
};
match output() {
@@ -111,13 +159,14 @@ async fn match_uri(
}
}
-pub async fn main(config: Arc<BackConfig>) -> Result<(), error::Error> {
+pub(crate) async fn main(config: Arc<BackConfig>) -> Result<(), error::Error> {
let addr: SocketAddr = ([127, 0, 0, 1], 8000).into();
let listener = TcpListener::bind(addr)
.await
.map_err(|err| error::Error::TcpBind { addr, err })?;
- info!("Listening on http://{}", addr);
+ info!("Listening on http://{addr}");
+
loop {
let (stream, _) = listener
.accept()
@@ -131,7 +180,7 @@ pub async fn main(config: Arc<BackConfig>) -> Result<(), error::Error> {
tokio::task::spawn(async move {
if let Err(err) = http1::Builder::new().serve_connection(io, service).await {
- error!("Error serving connection: {:?}", err);
+ error!("Error serving connection: {err:?}");
}
});
}
diff --git a/src/web/responses.rs b/src/web/responses.rs
index bcdcc0a..00af35a 100644
--- a/src/web/responses.rs
+++ b/src/web/responses.rs
@@ -12,10 +12,13 @@
use std::convert::Infallible;
use bytes::Bytes;
+use git_bug::replica::entity::id::prefix::IdPrefix;
use http::{Response, StatusCode, Version};
use http_body_util::{BodyExt, Full, combinators::BoxBody};
+use vy::{IntoHtml, h1, p, pre};
-use crate::{error, git_bug::format::HtmlString};
+use super::generate::templates::make_page;
+use crate::error;
pub(super) fn html_response<T: Into<Bytes>>(html_text: T) -> Response<BoxBody<Bytes, Infallible>> {
html_response_status(html_text, StatusCode::OK)
@@ -28,6 +31,15 @@ pub(super) fn html_response_status<T: Into<Bytes>>(
html_response_status_content_type(html_text, status, "text/html")
}
+pub(super) fn redirect(target: &str) -> Response<BoxBody<Bytes, Infallible>> {
+ Response::builder()
+ .status(StatusCode::MOVED_PERMANENTLY)
+ .version(Version::HTTP_2)
+ .header("Location", target)
+ .body(full(""))
+ .expect("This is hardcoded and will build")
+}
+
pub(super) fn html_response_status_content_type<T: Into<Bytes>>(
html_text: T,
status: StatusCode,
@@ -36,26 +48,129 @@ pub(super) fn html_response_status_content_type<T: Into<Bytes>>(
Response::builder()
.status(status)
.version(Version::HTTP_2)
- .header("Content-Type", format!("{}; charset=utf-8", content_type))
+ .header("Content-Type", format!("{content_type}; charset=utf-8"))
.header("x-content-type-options", "nosniff")
.header("x-frame-options", "SAMEORIGIN")
.body(full(html_text))
.expect("This will always build")
}
-fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, Infallible> {
+pub(super) fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, Infallible> {
Full::new(chunk.into()).boxed()
}
-// FIXME: Not all errors should return `INTERNAL_SERVER_ERROR`. <2025-03-08>
impl error::Error {
+ #[allow(clippy::too_many_lines)]
pub fn into_response(self) -> Response<BoxBody<Bytes, Infallible>> {
- html_response_status(
- format!(
- "<h1> Internal server error. </h1> <pre>Error: {}</pre>",
- HtmlString::from(self.to_string())
+ match self {
+ error::Error::ConfigParse { .. }
+ | error::Error::ProjectListRead { .. }
+ | error::Error::ConfigRead { .. }
+ | error::Error::RepoGetReferences(_)
+ | error::Error::RepoIssueRead(_)
+ | error::Error::RepoIdentityRead(_)
+ | error::Error::RepoFind { .. }
+ | error::Error::RepoRefsIter(_)
+ | error::Error::RepoRefsPrefixed { .. }
+ | error::Error::TcpBind { .. }
+ | error::Error::RepoOpen { .. }
+ | error::Error::TcpAccept { .. } => html_response_status(
+ make_page(
+ (
+ h1!("Internal server error"),
+ pre!(format!("Error {}", self.to_string())),
+ ),
+ "Error page",
+ Some("Error | Back"),
+ )
+ .into_string(),
+ StatusCode::INTERNAL_SERVER_ERROR,
+ ),
+ error::Error::NotGitBug { path } => html_response_status(
+ make_page(
+ (
+ h1!("Expectation Failed"),
+ p!(
+ "Repository '",
+ path.display().to_string(),
+ "' has no git bug data to show."
+ ),
+ ),
+ "Error page",
+ Some("Error | Back"),
+ )
+ .into_string(),
+ StatusCode::EXPECTATION_FAILED,
+ ),
+ error::Error::IssuesPrefixMissing { prefix, err } => html_response_status(
+ make_page(
+ (
+ h1!("Expectation Failed"),
+ p!(
+ "There is no issue associated with the prefix ",
+ "'",
+ prefix.to_string(),
+ "': ",
+ err.to_string()
+ ),
+ ),
+ "Error page",
+ Some("Error | Back"),
+ )
+ .into_string(),
+ StatusCode::EXPECTATION_FAILED,
+ ),
+ error::Error::IssuesPrefixParse { prefix, error } => html_response_status(
+ make_page(
+ (
+ h1!("Expectation Failed"),
+ p!(
+ "The prefix '",
+ prefix,
+ "' cannot be interperted as a prefix",
+ ),
+ p!(error.to_string()),
+ p!(
+ "The prefix is composed of ",
+ IdPrefix::REQUIRED_LENGTH,
+ " or more hex chars."
+ ),
+ ),
+ "Error page",
+ Some("Error | Back"),
+ )
+ .into_string(),
+ StatusCode::EXPECTATION_FAILED,
+ ),
+ error::Error::NotFound(path_buf) => html_response_status(
+ make_page(
+ (
+ h1!("Expectation Failed"),
+ p!(
+ "The path '",
+ path_buf.display().to_string(),
+ "' was unkonwn",
+ ),
+ ),
+ "Error page",
+ Some("Error | Back"),
+ )
+ .into_string(),
+ StatusCode::EXPECTATION_FAILED,
+ ),
+ error::Error::InvalidQuery { err, query } => html_response_status(
+ make_page(
+ (
+ h1!("Expectation Failed"),
+ p!("The query '", query, "' was invalid",),
+ p!(err.to_string()),
+ ),
+ "Error page",
+ Some("Error | Back"),
+ )
+ .into_string(),
+ StatusCode::EXPECTATION_FAILED,
),
- StatusCode::INTERNAL_SERVER_ERROR,
- )
+ }
}
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-06-27 15:48:35 +0000