Merge pull request #168 from dandi/mv-title

Pass site title to Templater, not DandiDav

Author: jwodder

src/dav/html.rs

@@ -15,15 +15,22 @@ use time::OffsetDateTime;
 static COLLECTION_TEMPLATE: &str = include_str!("templates/collection.html.tera");
 
 /// A template manager
-pub(crate) struct Templater(Tera);
+pub(crate) struct Templater {
+    /// Tera templater
+    engine: Tera,
+
+    /// Site title to display in HTML responses
+    title: String,
+}
 
 impl Templater {
-    /// Create a new templater and load all templates into it
+    /// Create a new templater with site title `title` and load all templates
+    /// into it
     ///
     /// # Errors
     ///
     /// If any template fails to load, a [`TemplateError::Load`] is returned.
-    pub(crate) fn load() -> Result<Self, TemplateError> {
+    pub(crate) fn new(title: String) -> Result<Self, TemplateError> {
         let mut engine = Tera::default();
         engine.register_filter("formatsize", FormatSizeFilter);
         engine
@@ -32,37 +39,77 @@ impl Templater {
                 template_name: "collection.html",
                 source,
             })?;
-        Ok(Templater(engine))
+        Ok(Templater { engine, title })
     }
 
     /// Render an HTML document containing a table listing the resources in
-    /// `entries` using the site title `title`.  `pathparts` contains the
-    /// individual components of the request URL path.
+    /// `entries`.  `pathparts` contains the individual components of the
+    /// request URL path.
     pub(super) fn render_collection(
         &self,
         entries: Vec<DavResource>,
-        title: &str,
         pathparts: Vec<Component>,
     ) -> Result<String, TemplateError> {
-        self.render_collection_from_context(CollectionContext::new(entries, title, pathparts))
-    }
-
-    fn render_collection_from_context(
-        &self,
-        context: CollectionContext,
-    ) -> Result<String, TemplateError> {
+        let template_name = "collection.html";
+        let colctx = self.collection_context(entries, pathparts);
         let context =
-            Context::from_serialize(context).map_err(|source| TemplateError::MakeContext {
-                template_name: "collection.html",
+            Context::from_serialize(colctx).map_err(|source| TemplateError::MakeContext {
+                template_name,
                 source,
             })?;
-        self.0
-            .render("collection.html", &context)
+        self.engine
+            .render(template_name, &context)
             .map_err(|source| TemplateError::Render {
-                template_name: "collection.html",
+                template_name,
                 source,
             })
     }
+
+    /// Construct the context for displaying the given `entries`.  `pathparts`
+    /// contains the individual components of the request URL path.
+    fn collection_context(
+        &self,
+        entries: Vec<DavResource>,
+        pathparts: Vec<Component>,
+    ) -> CollectionContext {
+        let mut rows = entries.into_iter().map(ColRow::from).collect::<Vec<_>>();
+        rows.sort_unstable();
+        if let Some((_, pp)) = pathparts.split_last() {
+            rows.insert(
+                0,
+                ColRow::parentdir(Href::from_path(&abs_dir_from_components(pp))),
+            );
+        }
+        let title_path = abs_dir_from_components(&pathparts);
+        let title = format!("{} \u{2014} {}", self.title, title_path);
+        CollectionContext {
+            title,
+            breadcrumbs: self.make_breadcrumbs(pathparts),
+            rows,
+            package_url: env!("CARGO_PKG_REPOSITORY"),
+            package_version: env!("CARGO_PKG_VERSION"),
+            package_commit: option_env!("GIT_COMMIT"),
+        }
+    }
+
+    /// Create breadcrumbs for the given request URL path components
+    fn make_breadcrumbs(&self, pathparts: Vec<Component>) -> Vec<Link> {
+        let mut links = Vec::with_capacity(pathparts.len().saturating_add(1));
+        let mut cumpath = String::from("/");
+        links.push(Link {
+            text: self.title.clone(),
+            href: Href::from_path(&cumpath),
+        });
+        for p in pathparts {
+            cumpath.push_str(&p);
+            cumpath.push('/');
+            links.push(Link {
+                text: p.into(),
+                href: Href::from_path(&cumpath),
+            });
+        }
+        links
+    }
 }
 
 /// Context to provide to the `collection.html` template
@@ -88,32 +135,6 @@ struct CollectionContext {
     package_commit: Option<&'static str>,
 }
 
-impl CollectionContext {
-    /// Construct the context for displaying the given `entries` using the site
-    /// title `title`.  `pathparts` contains the individual components of the
-    /// request URL path.
-    fn new(entries: Vec<DavResource>, title: &str, pathparts: Vec<Component>) -> CollectionContext {
-        let mut rows = entries.into_iter().map(ColRow::from).collect::<Vec<_>>();
-        rows.sort_unstable();
-        if let Some((_, pp)) = pathparts.split_last() {
-            rows.insert(
-                0,
-                ColRow::parentdir(Href::from_path(&abs_dir_from_components(pp))),
-            );
-        }
-        let title_path = abs_dir_from_components(&pathparts);
-        let full_title = format!("{title} \u{2014} {title_path}");
-        CollectionContext {
-            title: full_title,
-            breadcrumbs: make_breadcrumbs(title, pathparts),
-            rows,
-            package_url: env!("CARGO_PKG_REPOSITORY"),
-            package_version: env!("CARGO_PKG_VERSION"),
-            package_commit: option_env!("GIT_COMMIT"),
-        }
-    }
-}
-
 /// A hyperlink to display in an HTML document
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 struct Link {
@@ -165,7 +186,7 @@ struct ColRow {
 
 impl ColRow {
     /// Construct a `ColRow` representing the parent of the current collection,
-    /// served at `href`
+    /// with the parent being served at `href`
     fn parentdir(href: Href) -> ColRow {
         ColRow {
             name: "..".to_owned(),
@@ -261,27 +282,6 @@ fn maybe_timestamp<S: Serializer>(
     }
 }
 
-/// Create breadcrumbs for the given request URL path components.
-///
-/// `title` is the site title, for use as the text of the first breadcrumb.
-fn make_breadcrumbs(title: &str, pathparts: Vec<Component>) -> Vec<Link> {
-    let mut links = Vec::with_capacity(pathparts.len().saturating_add(1));
-    let mut cumpath = String::from("/");
-    links.push(Link {
-        text: title.to_owned(),
-        href: Href::from_path(&cumpath),
-    });
-    for p in pathparts {
-        cumpath.push_str(&p);
-        cumpath.push('/');
-        links.push(Link {
-            text: p.into(),
-            href: Href::from_path(&cumpath),
-        });
-    }
-    links
-}
-
 /// Given an iterator of `&Component` values, join them together with forward
 /// slashes and add a leading & trailing slash.
 fn abs_dir_from_components<'a, I>(iter: I) -> String
@@ -344,7 +344,7 @@ mod tests {
         assert_eq!(formatsize(size), s);
     }
 
-    mod render_collection_from_context {
+    mod render_collection {
         use super::*;
         use crate::dav::{DavContent, DavResourceWithChildren};
         use pretty_assertions::assert_eq;
@@ -353,7 +353,7 @@ mod tests {
 
         #[test]
         fn basic() {
-            let templater = Templater::load().unwrap();
+            let templater = Templater::new("Dandidav Test".to_owned()).unwrap();
             let entries = vec![
                 DavResource::Collection(DavCollection {
                     path: Some("foo/bar/baz/a.zarr/".parse().unwrap()),
@@ -421,16 +421,16 @@ mod tests {
                     metadata_url: None,
                 }),
             ];
-            let context = CollectionContext::new(
-                entries,
-                "Dandidav Test",
-                vec![
-                    "foo".parse().unwrap(),
-                    "bar".parse().unwrap(),
-                    "baz".parse().unwrap(),
-                ],
-            );
-            let rendered = templater.render_collection_from_context(context).unwrap();
+            let rendered = templater
+                .render_collection(
+                    entries,
+                    vec![
+                        "foo".parse().unwrap(),
+                        "bar".parse().unwrap(),
+                        "baz".parse().unwrap(),
+                    ],
+                )
+                .unwrap();
             let commit_str = match option_env!("GIT_COMMIT") {
                 Some(s) => Cow::from(format!(", commit {s}")),
                 None => Cow::from(""),
@@ -451,14 +451,13 @@ mod tests {
 
         #[test]
         fn root() {
-            let templater = Templater::load().unwrap();
+            let templater = Templater::new("Dandidav Test".to_owned()).unwrap();
             let DavResourceWithChildren::Collection { children, .. } =
                 DavResourceWithChildren::root()
             else {
                 panic!("DavResourceWithChildren::root() should be a Collection");
             };
-            let context = CollectionContext::new(children, "Dandidav Test", Vec::new());
-            let rendered = templater.render_collection_from_context(context).unwrap();
+            let rendered = templater.render_collection(children, Vec::new()).unwrap();
             let commit_str = match option_env!("GIT_COMMIT") {
                 Some(s) => Cow::from(format!(", commit {s}")),
                 None => Cow::from(""),

src/dav/mod.rs

@@ -45,9 +45,6 @@ pub(crate) struct DandiDav {
     /// Manager for templating of HTML responses
     pub(crate) templater: Templater,
 
-    /// Site title to display in HTML responses
-    pub(crate) title: String,
-
     /// Whether `GET` requests for blob assets should be responded to with
     /// redirects to S3 (`true`) or to Archive download URLs that then redirect
     /// to S3 (`false`).  The latter setting results in the final response
@@ -133,9 +130,7 @@ impl DandiDav {
     ) -> Result<Response<Body>, DavError> {
         match self.get_resource_with_children(path).await? {
             DavResourceWithChildren::Collection { children, .. } => {
-                let html = self
-                    .templater
-                    .render_collection(children, &self.title, pathparts)?;
+                let html = self.templater.render_collection(children, pathparts)?;
                 Ok(([(CONTENT_TYPE, HTML_CONTENT_TYPE)], html).into_response())
             }
             DavResourceWithChildren::Item(DavItem {

src/main.rs

@@ -98,12 +98,11 @@ async fn run() -> anyhow::Result<()> {
     let args = Arguments::parse();
     let dandi = DandiClient::new(args.api_url)?;
     let zarrman = ZarrManClient::new()?;
-    let templater = Templater::load()?;
+    let templater = Templater::new(args.title)?;
     let dav = Arc::new(DandiDav {
         dandi,
         zarrman,
         templater,
-        title: args.title,
         prefer_s3_redirects: args.prefer_s3_redirects,
     });
     let app = Router::new()