Support pagination.

ibz · ibz · commit f664caf38dd6 · 2026-01-11T20:20:30.000+02:00
diff --git a/src/main.rs b/src/main.rs
@@ -292,12 +292,13 @@ async fn handle_websocket(
     Ok(())
 }
 
-fn get_default_index(slug: &str) -> Resource {
+fn get_default_index(slug: &str, page_number: Option<usize>) -> Resource {
     Resource {
         kind: ResourceKind::Page,
         slug: slug.to_string(),
         date: Utc::now().naive_utc(),
         event_id: None,
+        page_number,
     }
 }
 
@@ -436,15 +437,37 @@ async fn handle_request(request: Request<State>) -> tide::Result<Response> {
             if let Some(r) = resources.get(&resource_path) {
                 page = Some(Page::from_resource(r, &site)?);
             } else {
-                let mut slug = request.url().path_segments().unwrap().last().unwrap();
+                let last_two: Vec<&str> = request
+                    .url()
+                    .path_segments()
+                    .unwrap()
+                    .rev()
+                    .take(2)
+                    .collect();
+                let (last, second_last) = match &last_two[..] {
+                    [last, second_last] => (Some(*last), Some(*second_last)),
+                    [last] => (Some(*last), None),
+                    [] => (None, None),
+                    _ => unreachable!(),
+                };
+                let page_number = if let Some(last) = last {
+                    last.parse::<usize>().ok()
+                } else {
+                    None
+                };
+                let mut slug = if page_number.is_some() {
+                    second_last.unwrap_or(&"")
+                } else {
+                    last.unwrap_or(&"")
+                };
                 if slug == "" {
                     slug = "index";
                 }
-                let default_index = get_default_index(&slug);
+                let default_index = get_default_index(&slug, page_number);
                 let r = resources
                     .get(&format!("/{}", &slug))
                     .unwrap_or(&default_index);
-                if resource_path == "/" {
+                if slug == "index" {
                     match &site.config.homepage_filter {
                         Some(HomepageFilter::Posts) | None => {
                             posts_section = Some(Section::from_resource(r, &site)?);
@@ -460,13 +483,13 @@ async fn handle_request(request: Request<State>) -> tide::Result<Response> {
                         }
                     }
                 }
-                if resource_path == "/posts" {
+                if slug == "posts" {
                     posts_section = Some(Section::from_resource(r, &site)?);
-                } else if resource_path == "/notes" {
+                } else if slug == "notes" {
                     notes_section = Some(Section::from_resource(r, &site)?);
-                } else if resource_path == "/pictures" {
+                } else if slug == "pictures" {
                     pictures_section = Some(Section::from_resource(r, &site)?);
-                } else if resource_path == "/listings" {
+                } else if slug == "listings" {
                     listings_section = Some(Section::from_resource(r, &site)?);
                 }
             }
@@ -1341,7 +1364,10 @@ fn validate_themes(
         }
         match render_and_build_response(
             &empty_site,
-            Section::<PostSectionFilter>::from_resource(&get_default_index("index"), &empty_site)?,
+            Section::<PostSectionFilter>::from_resource(
+                &get_default_index("index", None),
+                &empty_site,
+            )?,
         ) {
             Err(e) => {
                 let mut error_str = format!("{}", e);
diff --git a/src/resource.rs b/src/resource.rs
@@ -7,7 +7,7 @@ use url::Url;
 
 use crate::site::{ServusMetadata, Site};
 
-#[derive(Clone, Copy, PartialEq, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
 pub enum ResourceKind {
     Post,
     Page,
@@ -99,7 +99,9 @@ impl Renderable for Page {
 
         Ok(Self {
             title,
-            permalink: site.config.make_permalink(&site.domain, &resource_url),
+            permalink: site
+                .config
+                .make_permalink(&site.domain, &resource_url, None),
             url: resource_url.clone(),
             slug: resource.slug.to_owned(),
             path: Some(resource_url),
@@ -187,6 +189,7 @@ pub struct Section<T> {
     pages: Vec<Page>,
     content: String,
     description: Option<String>,
+    paginator: Paginator,
     _phantom: PhantomData<T>,
 }
 
@@ -198,27 +201,77 @@ where
         let Some(resource_url) = resource.get_resource_url() else {
             bail!("Cannot render a resource without URL");
         };
+
+        let current_index = resource.page_number.unwrap_or(1);
+        let paginate_by = site
+            .config
+            .sections
+            .iter()
+            .find(|s| s.name == resource.slug)
+            .map_or(0, |s| s.paginate_by.unwrap_or(0));
+
         let Ok(resources) = site.resources.read() else {
             bail!("Cannot access resources");
         };
-        let mut resources_list = resources.values().collect::<Vec<&Resource>>();
-        resources_list.sort_by(|a, b| b.date.cmp(&a.date));
-        let pages_list = resources_list
+        let mut resources = resources.values().collect::<Vec<&Resource>>();
+        resources.sort_by(|a, b| b.date.cmp(&a.date));
+
+        let mut all_pages = Vec::new();
+        let mut current_pager_pages = Vec::new();
+        let pager_start = (current_index - 1) * paginate_by;
+        let pager_end = pager_start + paginate_by;
+        for (i, page) in resources
             .into_iter()
             .filter(|r| T::filter(r.kind))
             .map(|r| Page::from_resource(r, site))
             .filter_map(Result::ok)
-            .collect::<Vec<Page>>();
+            .enumerate()
+        {
+            if i >= pager_start && i < pager_end || paginate_by == 0 {
+                current_pager_pages.push(page.clone());
+            }
+            all_pages.push(page);
+        }
+
+        let number_pagers = match paginate_by {
+            0 => 0,
+            _ => all_pages.len().div_ceil(paginate_by),
+        };
 
         Ok(Self {
             title: None,
-            permalink: site.config.make_permalink(&site.domain, &resource_url),
+            permalink: site
+                .config
+                .make_permalink(&site.domain, &resource_url, Some(current_index)),
             url: resource_url,
             slug: resource.slug.to_owned(),
             path: None,        // TODO
             description: None, // TODO
             content: String::new(),
-            pages: pages_list,
+            pages: all_pages,
+            paginator: Paginator {
+                current_index,
+                number_pagers,
+                previous: if current_index > 1 {
+                    Some(site.config.make_permalink(
+                        &site.domain,
+                        &resource.slug,
+                        Some(current_index - 1),
+                    ))
+                } else {
+                    None
+                },
+                next: if current_index < number_pagers {
+                    Some(site.config.make_permalink(
+                        &site.domain,
+                        &resource.slug,
+                        Some(current_index + 1),
+                    ))
+                } else {
+                    None
+                },
+                pages: current_pager_pages,
+            },
             _phantom: PhantomData,
         })
     }
@@ -238,19 +291,8 @@ where
 
         extra_context.insert("config", &site.config);
 
-        // NB: some themes expect to iterate over section.pages, others look for paginator.pages.
-        // We are currently passing both in all cases, so all themes will find the pages.
         extra_context.insert("section", &self);
-
-        // TODO: paginator.pages should be paginated, but it is not.
-        extra_context.insert(
-            "paginator",
-            &Paginator {
-                current_index: 1,
-                number_pagers: 1,
-                pages: self.pages.clone(),
-            },
-        );
+        extra_context.insert("paginator", &self.paginator);
 
         // https://www.getzola.org/documentation/templates/pages-sections/
         let template = match self.slug.as_str() {
@@ -273,15 +315,18 @@ where
 struct Paginator {
     current_index: usize,
     number_pagers: usize,
+    previous: Option<String>,
+    next: Option<String>,
     pages: Vec<Page>,
 }
 
-#[derive(Clone, Serialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct Resource {
     pub kind: ResourceKind,
     pub slug: String,
     pub date: NaiveDateTime, // this is nice to have here for sorting
     pub event_id: Option<String>,
+    pub page_number: Option<usize>,
 }
 
 impl Resource {
diff --git a/src/site.rs b/src/site.rs
@@ -67,6 +67,12 @@ pub enum HomepageFilter {
     Listings,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct SectionConfig {
+    pub name: String,
+    pub paginate_by: Option<usize>,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct SiteConfig {
     pub base_url: String,
@@ -78,6 +84,11 @@ pub struct SiteConfig {
     pub description: Option<String>,
     pub homepage_filter: Option<HomepageFilter>,
 
+    // a way to store section config (such as per-section paginate_by)
+    // which in Zola would normally go to the section's front matter
+    #[serde(default)]
+    pub sections: Vec<SectionConfig>,
+
     // required by some themes
     pub author: Option<String>,
     #[serde(default = "default_feed_filename")]
@@ -104,6 +115,7 @@ impl SiteConfig {
             title: None,
             description: None,
             homepage_filter: None,
+            sections: vec![],
             author: None,
             feed_filename: default_feed_filename(),
             feed_filenames: default_feed_filenames(),
@@ -142,7 +154,12 @@ impl SiteConfig {
     // https://github.com/getzola/zola/blob/master/components/config/src/config/mod.rs
 
     /// Makes a url, taking into account that the base url might have a trailing slash
-    pub fn make_permalink(&self, site_domain: &str, path: &str) -> String {
+    pub fn make_permalink(
+        &self,
+        site_domain: &str,
+        path: &str,
+        page_number: Option<usize>,
+    ) -> String {
         let trailing_bit = if path.ends_with('/')
             || path.ends_with("atom.xml")
             || path.ends_with(".css")
@@ -154,7 +171,7 @@ impl SiteConfig {
         };
 
         // Index section with a base url that has a trailing slash
-        let permalink = if self.base_url.ends_with('/') && path == "/" {
+        let mut permalink = if self.base_url.ends_with('/') && path == "/" {
             self.base_url.to_string()
         } else if path == "/" {
             // index section with a base url that doesn't have a trailing slash
@@ -167,6 +184,10 @@ impl SiteConfig {
             format!("{}/{}{}", self.base_url, path, trailing_bit)
         };
 
+        if let Some(page_number) = page_number {
+            permalink = format!("{}{}", permalink, page_number);
+        }
+
         if self.is_local_server() {
             // rewrite links when running locally
             // to allow the server know what site they are referring to
@@ -330,6 +351,7 @@ impl Site {
                     }
                     .to_string(),
                     event_id: Some(event.id.clone()),
+                    page_number: None,
                 };
 
                 if let Some(url) = resource.get_resource_url() {
@@ -413,6 +435,7 @@ impl Site {
                 }
                 .to_string(),
                 event_id: Some(event.id.to_owned()),
+                page_number: None,
             };
 
             if let Some(url) = resource.get_resource_url() {
diff --git a/src/template.rs b/src/template.rs
@@ -80,7 +80,10 @@ impl TeraFn for GetUrl {
 
         let path = segments.join("/");
 
-        let mut permalink = self.site.config.make_permalink(&self.site.domain, &path);
+        let mut permalink = self
+            .site
+            .config
+            .make_permalink(&self.site.domain, &path, None);
         if !trailing_slash && permalink.ends_with('/') {
             permalink.pop(); // Removes the slash
         }
