From be784bbaa3b1dc24d16660d943a1844dab15befd Mon Sep 17 00:00:00 2001 From: Vincent Prouillet Date: Tue, 16 May 2017 13:37:00 +0900 Subject: [PATCH] Refactor taxonomies Fix #66 --- CHANGELOG.md | 5 + src/bin/console.rs | 8 +- src/bin/rebuild.rs | 19 ++- src/content/mod.rs | 2 + src/content/page.rs | 5 +- src/content/section.rs | 2 +- src/content/taxonomies.rs | 135 +++++++++++++++++ src/front_matter/page.rs | 3 - src/{utils.rs => fs.rs} | 9 ++ src/lib.rs | 4 +- src/site.rs | 226 ++++++++-------------------- test_site/templates/categories.html | 2 +- test_site/templates/category.html | 4 +- test_site/templates/tag.html | 4 +- test_site/templates/tags.html | 2 +- tests/site.rs | 4 +- 16 files changed, 248 insertions(+), 186 deletions(-) create mode 100644 src/content/taxonomies.rs rename src/{utils.rs => fs.rs} (80%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8b54836..d63b464 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## 0.0.6 (unreleased) + +- Fix missing serialized data for sections +- Change the single item template context for categories/tags + ## 0.0.5 (2017-05-15) - Fix XML templates overriding and reloading diff --git a/src/bin/console.rs b/src/bin/console.rs index ad6b5a0..82f63ff 100644 --- a/src/bin/console.rs +++ b/src/bin/console.rs @@ -36,13 +36,17 @@ pub fn notify_site_size(site: &Site) { /// Display a warning in the console if there are ignored pages in the site pub fn warn_about_ignored_pages(site: &Site) { - let ignored_pages = site.get_ignored_pages(); + let ignored_pages: Vec<_> = site.sections + .values() + .flat_map(|s| s.ignored_pages.iter().map(|p| p.file.path.clone())) + .collect(); + if !ignored_pages.is_empty() { warn(&format!( "{} page(s) ignored (missing date or order in a sorted section):", ignored_pages.len() )); - for path in site.get_ignored_pages() { + for path in ignored_pages { warn(&format!("- {}", path.display())); } } diff --git a/src/bin/rebuild.rs b/src/bin/rebuild.rs index afb0ed3..93e778f 100644 --- a/src/bin/rebuild.rs +++ b/src/bin/rebuild.rs @@ -1,8 +1,21 @@ use std::path::Path; -use gutenberg::{Site, SectionFrontMatter, PageFrontMatter}; +use gutenberg::{Site, Page, Section, SectionFrontMatter, PageFrontMatter}; use gutenberg::errors::Result; + +/// Finds the section that contains the page given if there is one +pub fn find_parent_section<'a>(site: &'a Site, page: &Page) -> Option<&'a Section> { + for section in site.sections.values() { + if section.is_child_page(page) { + return Some(section) + } + } + + None +} + + #[derive(Debug, Clone, Copy, PartialEq)] enum PageChangesNeeded { /// Editing `tags` @@ -101,7 +114,7 @@ pub fn after_content_change(site: &mut Site, path: &Path) -> Result<()> { site.populate_tags_and_categories(); } - if site.find_parent_section(&p).is_some() { + if find_parent_section(site, &p).is_some() { site.populate_sections(); } }; @@ -171,7 +184,7 @@ pub fn after_content_change(site: &mut Site, path: &Path) -> Result<()> { site.render_categories()?; }, PageChangesNeeded::Sort => { - let section_path = match site.find_parent_section(&site.pages[path]) { + let section_path = match find_parent_section(site, &site.pages[path]) { Some(s) => s.file.path.clone(), None => continue // Do nothing if it's an orphan page }; diff --git a/src/content/mod.rs b/src/content/mod.rs index 841ca67..b7f9fd7 100644 --- a/src/content/mod.rs +++ b/src/content/mod.rs @@ -4,9 +4,11 @@ mod section; mod sorting; mod utils; mod file_info; +mod taxonomies; pub use self::page::{Page}; pub use self::section::{Section}; pub use self::pagination::{Paginator, Pager}; pub use self::sorting::{SortBy, sort_pages, populate_previous_and_next_pages}; +pub use self::taxonomies::{Taxonomy, TaxonomyItem}; diff --git a/src/content/page.rs b/src/content/page.rs index bead6b8..0883b43 100644 --- a/src/content/page.rs +++ b/src/content/page.rs @@ -12,7 +12,7 @@ use errors::{Result, ResultExt}; use config::Config; use front_matter::{PageFrontMatter, split_page_content}; use markdown::markdown_to_html; -use utils::{read_file}; +use fs::{read_file}; use content::utils::{find_related_assets, get_reading_analytics}; use content::file_info::FileInfo; @@ -163,7 +163,7 @@ impl Default for Page { impl ser::Serialize for Page { fn serialize(&self, serializer: S) -> StdResult where S: ser::Serializer { - let mut state = serializer.serialize_struct("page", 16)?; + let mut state = serializer.serialize_struct("page", 15)?; state.serialize_field("content", &self.content)?; state.serialize_field("title", &self.meta.title)?; state.serialize_field("description", &self.meta.description)?; @@ -173,7 +173,6 @@ impl ser::Serialize for Page { state.serialize_field("permalink", &self.permalink)?; state.serialize_field("summary", &self.summary)?; state.serialize_field("tags", &self.meta.tags)?; - state.serialize_field("draft", &self.meta.draft)?; state.serialize_field("category", &self.meta.category)?; state.serialize_field("extra", &self.meta.extra)?; let (word_count, reading_time) = get_reading_analytics(&self.raw_content); diff --git a/src/content/section.rs b/src/content/section.rs index 4b04f22..3d3f79b 100644 --- a/src/content/section.rs +++ b/src/content/section.rs @@ -8,7 +8,7 @@ use serde::ser::{SerializeStruct, self}; use config::Config; use front_matter::{SectionFrontMatter, split_section_content}; use errors::{Result, ResultExt}; -use utils::{read_file}; +use fs::{read_file}; use markdown::markdown_to_html; use content::Page; use content::file_info::FileInfo; diff --git a/src/content/taxonomies.rs b/src/content/taxonomies.rs new file mode 100644 index 0000000..1f507ae --- /dev/null +++ b/src/content/taxonomies.rs @@ -0,0 +1,135 @@ +use std::collections::HashMap; + +use slug::slugify; +use tera::{Context, Tera}; + +use config::Config; +use errors::{Result, ResultExt}; +use content::Page; + + +#[derive(Debug, Copy, Clone, PartialEq)] +pub enum TaxonomyKind { + Tags, + Categories, +} + +/// A tag or category +#[derive(Debug, Clone, Serialize, PartialEq)] +pub struct TaxonomyItem { + pub name: String, + pub slug: String, + pub pages: Vec, +} + +impl TaxonomyItem { + pub fn new(name: &str, pages: Vec) -> TaxonomyItem { + TaxonomyItem { + name: name.to_string(), + slug: slugify(name), + pages, + } + } +} + +/// All the tags or categories +#[derive(Debug, Clone, PartialEq)] +pub struct Taxonomy { + pub kind: TaxonomyKind, + // this vec is sorted by the count of item + pub items: Vec, +} + +impl Taxonomy { + // TODO: take a Vec<&'a Page> if it makes a difference in terms of perf for actual sites + pub fn find_tags_and_categories(all_pages: Vec) -> (Taxonomy, Taxonomy) { + let mut tags = HashMap::new(); + let mut categories = HashMap::new(); + + // Find all the tags/categories first + for page in all_pages { + if let Some(ref category) = page.meta.category { + categories + .entry(category.to_string()) + .or_insert_with(|| vec![]) + .push(page.clone()); + } + + if let Some(ref t) = page.meta.tags { + for tag in t { + tags + .entry(tag.to_string()) + .or_insert_with(|| vec![]) + .push(page.clone()); + } + } + } + + // Then make TaxonomyItem out of them, after sorting it + let tags_taxonomy = Taxonomy::new(TaxonomyKind::Tags, tags); + let categories_taxonomy = Taxonomy::new(TaxonomyKind::Categories, categories); + + (tags_taxonomy, categories_taxonomy) + } + + fn new(kind: TaxonomyKind, items: HashMap>) -> Taxonomy { + let mut sorted_items = vec![]; + for (name, pages) in &items { + sorted_items.push( + TaxonomyItem::new(name, pages.clone()) + ); + } + sorted_items.sort_by(|a, b| b.pages.len().cmp(&a.pages.len())); + + Taxonomy { + kind, + items: sorted_items, + } + } + + pub fn len(&self) -> usize { + self.items.len() + } + + pub fn get_single_item_name(&self) -> String { + match self.kind { + TaxonomyKind::Tags => "tag".to_string(), + TaxonomyKind::Categories => "category".to_string(), + } + } + + pub fn get_list_name(&self) -> String { + match self.kind { + TaxonomyKind::Tags => "tags".to_string(), + TaxonomyKind::Categories => "categories".to_string(), + } + } + + pub fn render_single_item(&self, item: &TaxonomyItem, tera: &Tera, config: &Config) -> Result { + let name = self.get_single_item_name(); + let mut context = Context::new(); + context.add("config", config); + // TODO: how to sort categories and tag content? + // Have a setting in config.toml or a _category.md and _tag.md + // The latter is more in line with the rest of Gutenberg but order ordering + // doesn't really work across sections. + context.add(&name, item); + context.add("current_url", &config.make_permalink(&format!("{}/{}", name, item.slug))); + context.add("current_path", &format!("/{}/{}", name, item.slug)); + + tera.render(&format!("{}.html", name), &context) + .chain_err(|| format!("Failed to render {} page.", name)) + } + + pub fn render_list(&self, tera: &Tera, config: &Config) -> Result { + let name = self.get_list_name(); + let mut context = Context::new(); + context.add("config", config); + context.add(&name, &self.items); + context.add("current_url", &config.make_permalink(&name)); + context.add("current_path", &name); + + tera.render(&format!("{}.html", name), &context) + .chain_err(|| format!("Failed to render {} page.", name)) + } +} diff --git a/src/front_matter/page.rs b/src/front_matter/page.rs index 07c1fb2..9613c8f 100644 --- a/src/front_matter/page.rs +++ b/src/front_matter/page.rs @@ -24,8 +24,6 @@ pub struct PageFrontMatter { pub url: Option, /// Tags, not to be confused with categories pub tags: Option>, - /// Whether this page is a draft and should be published or not - pub draft: Option, /// Only one category allowed. Can't be an empty string if present pub category: Option, /// Integer to use to order content. Lowest is at the bottom, highest first @@ -100,7 +98,6 @@ impl Default for PageFrontMatter { slug: None, url: None, tags: None, - draft: None, category: None, order: None, template: None, diff --git a/src/utils.rs b/src/fs.rs similarity index 80% rename from src/utils.rs rename to src/fs.rs index bb2c983..43572cc 100644 --- a/src/utils.rs +++ b/src/fs.rs @@ -11,6 +11,15 @@ pub fn create_file>(path: P, content: &str) -> Result<()> { Ok(()) } +/// Create a directory at the given path if it doesn't exist already +pub fn ensure_directory_exists>(path: P) -> Result<()> { + let path = path.as_ref(); + if !path.exists() { + create_directory(&path)?; + } + Ok(()) +} + /// Very similar to `create_dir` from the std except it checks if the folder /// exists before creating it pub fn create_directory>(path: P) -> Result<()> { diff --git a/src/lib.rs b/src/lib.rs index 46b9ee0..cd21787 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -19,7 +19,7 @@ extern crate base64; #[cfg(test)] extern crate tempdir; -mod utils; +mod fs; mod config; pub mod errors; mod front_matter; @@ -33,5 +33,5 @@ pub use site::{Site}; pub use config::{Config, get_config}; pub use front_matter::{PageFrontMatter, SectionFrontMatter, split_page_content, split_section_content}; pub use content::{Page, Section, SortBy, sort_pages, populate_previous_and_next_pages}; -pub use utils::{create_file}; +pub use fs::{create_file}; pub use markdown::markdown_to_html; diff --git a/src/site.rs b/src/site.rs index 5348758..1d50c43 100644 --- a/src/site.rs +++ b/src/site.rs @@ -1,47 +1,24 @@ -use std::collections::{HashMap}; -use std::iter::FromIterator; +use std::collections::HashMap; use std::fs::{remove_dir_all, copy, create_dir_all}; use std::path::{Path, PathBuf}; use glob::glob; use tera::{Tera, Context}; -use slug::slugify; use walkdir::WalkDir; use errors::{Result, ResultExt}; use config::{Config, get_config}; -use utils::{create_file, create_directory}; -use content::{Page, Section, Paginator, SortBy, populate_previous_and_next_pages, sort_pages}; +use fs::{create_file, create_directory, ensure_directory_exists}; +use content::{Page, Section, Paginator, SortBy, Taxonomy, populate_previous_and_next_pages, sort_pages}; use templates::{GUTENBERG_TERA, global_fns, render_redirect_template}; -#[derive(Debug, PartialEq)] -enum RenderList { - Tags, - Categories, -} - -/// A tag or category -#[derive(Debug, Serialize, PartialEq)] -struct ListItem { - name: String, - slug: String, - count: usize, -} - -impl ListItem { - pub fn new(name: &str, count: usize) -> ListItem { - ListItem { - name: name.to_string(), - slug: slugify(name), - count: count, - } - } -} #[derive(Debug)] pub struct Site { + /// The base path of the gutenberg site pub base_path: PathBuf, + /// The parsed config for the site pub config: Config, pub pages: HashMap, pub sections: HashMap, @@ -49,8 +26,8 @@ pub struct Site { live_reload: bool, output_path: PathBuf, static_path: PathBuf, - pub tags: HashMap>, - pub categories: HashMap>, + pub tags: Option, + pub categories: Option, /// A map of all .md files (section and pages) and their permalink /// We need that if there are relative links in the content that need to be resolved pub permalinks: HashMap, @@ -75,8 +52,8 @@ impl Site { live_reload: false, output_path: path.join("public"), static_path: path.join("static"), - tags: HashMap::new(), - categories: HashMap::new(), + tags: None, + categories: None, permalinks: HashMap::new(), }; @@ -88,15 +65,6 @@ impl Site { self.live_reload = true; } - /// Gets the path of all ignored pages in the site - /// Used for reporting them in the CLI - pub fn get_ignored_pages(&self) -> Vec { - self.sections - .values() - .flat_map(|s| s.ignored_pages.iter().map(|p| p.file.path.clone())) - .collect() - } - /// Get all the orphan (== without section) pages in the site pub fn get_all_orphan_pages(&self) -> Vec<&Page> { let mut pages_in_sections = vec![]; @@ -115,17 +83,6 @@ impl Site { orphans } - /// Finds the section that contains the page given if there is one - pub fn find_parent_section(&self, page: &Page) -> Option<&Section> { - for section in self.sections.values() { - if section.is_child_page(page) { - return Some(section) - } - } - - None - } - /// Used by tests to change the output path to a tmp dir #[doc(hidden)] pub fn set_output_path>(&mut self, path: P) { @@ -251,24 +208,23 @@ impl Site { } } - /// Separated from `parse` for easier testing + /// Find all the tags and categories if it's asked in the config pub fn populate_tags_and_categories(&mut self) { - for page in self.pages.values() { - if let Some(ref category) = page.meta.category { - self.categories - .entry(category.to_string()) - .or_insert_with(|| vec![]) - .push(page.file.path.clone()); - } + let generate_tags_pages = self.config.generate_tags_pages.unwrap(); + let generate_categories_pages = self.config.generate_categories_pages.unwrap(); + if !generate_tags_pages && !generate_categories_pages { + return; + } - if let Some(ref tags) = page.meta.tags { - for tag in tags { - self.tags - .entry(tag.to_string()) - .or_insert_with(|| vec![]) - .push(page.file.path.clone()); - } - } + // TODO: can we pass a reference? + let (tags, categories) = Taxonomy::find_tags_and_categories( + self.pages.values().cloned().collect::>() + ); + if generate_tags_pages { + self.tags = Some(tags); + } + if generate_categories_pages { + self.categories = Some(categories); } } @@ -284,14 +240,6 @@ impl Site { html } - fn ensure_public_directory_exists(&self) -> Result<()> { - let public = self.output_path.clone(); - if !public.exists() { - create_directory(&public)?; - } - Ok(()) - } - /// Copy static file to public directory. pub fn copy_static_file>(&self, path: P) -> Result<()> { let relative_path = path.as_ref().strip_prefix(&self.static_path).unwrap(); @@ -333,7 +281,7 @@ impl Site { /// Renders a single content page pub fn render_page(&self, page: &Page) -> Result<()> { - self.ensure_public_directory_exists()?; + ensure_directory_exists(&self.output_path)?; // Copy the nesting of the content directory if we have sections for that page let mut current_path = self.output_path.to_path_buf(); @@ -362,7 +310,7 @@ impl Site { Ok(()) } - /// Builds the site to the `public` directory after deleting it + /// Deletes the `public` directory and builds the site pub fn build(&self) -> Result<()> { self.clean()?; self.render_sections()?; @@ -382,98 +330,45 @@ impl Site { /// Renders robots.txt pub fn render_robots(&self) -> Result<()> { - self.ensure_public_directory_exists()?; + ensure_directory_exists(&self.output_path)?; create_file( self.output_path.join("robots.txt"), &self.tera.render("robots.txt", &Context::new())? ) } - /// Renders all categories if the config allows it + /// Renders all categories and the single category pages if there are some pub fn render_categories(&self) -> Result<()> { - if self.config.generate_categories_pages.unwrap() { - self.render_categories_and_tags(RenderList::Categories) - } else { - Ok(()) + if let Some(ref categories) = self.categories { + self.render_taxonomy(categories)?; } + + Ok(()) } - /// Renders all tags if the config allows it + /// Renders all tags and the single tag pages if there are some pub fn render_tags(&self) -> Result<()> { - if self.config.generate_tags_pages.unwrap() { - self.render_categories_and_tags(RenderList::Tags) - } else { - Ok(()) + if let Some(ref tags) = self.tags { + self.render_taxonomy(tags)?; } - } - - /// Render the /{categories, list} pages and each individual category/tag page - /// They are the same thing fundamentally, a list of pages with something in common - /// TODO: revisit this function, lots of things have changed since then - fn render_categories_and_tags(&self, kind: RenderList) -> Result<()> { - let items = match kind { - RenderList::Categories => &self.categories, - RenderList::Tags => &self.tags, - }; - if items.is_empty() { - return Ok(()); - } + Ok(()) + } - let (list_tpl_name, single_tpl_name, name, var_name) = if kind == RenderList::Categories { - ("categories.html", "category.html", "categories", "category") - } else { - ("tags.html", "tag.html", "tags", "tag") - }; - self.ensure_public_directory_exists()?; + fn render_taxonomy(&self, taxonomy: &Taxonomy) -> Result<()> { + ensure_directory_exists(&self.output_path)?; - // Create the categories/tags directory first - let public = self.output_path.clone(); - let mut output_path = public.to_path_buf(); - output_path.push(name); + let output_path = self.output_path.join(&taxonomy.get_list_name()); + let list_output = taxonomy.render_list(&self.tera, &self.config)?; create_directory(&output_path)?; - - // Then render the index page for that kind. - // We sort by number of page in that category/tag - let mut sorted_items = vec![]; - for (item, count) in Vec::from_iter(items).into_iter().map(|(a, b)| (a, b.len())) { - sorted_items.push(ListItem::new(item, count)); - } - sorted_items.sort_by(|a, b| b.count.cmp(&a.count)); - let mut context = Context::new(); - context.add(name, &sorted_items); - context.add("config", &self.config); - context.add("current_url", &self.config.make_permalink(name)); - context.add("current_path", &format!("/{}", name)); - // And render it immediately - let list_output = self.tera.render(list_tpl_name, &context)?; create_file(output_path.join("index.html"), &self.inject_livereload(list_output))?; - // Now, each individual item - for (item_name, pages_paths) in items.iter() { - let pages: Vec<&Page> = self.pages - .iter() - .filter(|&(path, _)| pages_paths.contains(path)) - .map(|(_, page)| page) - .collect(); - // TODO: how to sort categories and tag content? - // Have a setting in config.toml or a _category.md and _tag.md - // The latter is more in line with the rest of Gutenberg but order ordering - // doesn't really work across sections. - - let mut context = Context::new(); - let slug = slugify(&item_name); - context.add(var_name, &item_name); - context.add(&format!("{}_slug", var_name), &slug); - context.add("pages", &pages); - context.add("config", &self.config); - context.add("current_url", &self.config.make_permalink(&format!("{}/{}", name, slug))); - context.add("current_path", &format!("/{}/{}", name, slug)); - let single_output = self.tera.render(single_tpl_name, &context)?; - - create_directory(&output_path.join(&slug))?; + for item in &taxonomy.items { + let single_output = taxonomy.render_single_item(item, &self.tera, &self.config)?; + + create_directory(&output_path.join(&item.slug))?; create_file( - output_path.join(&slug).join("index.html"), + output_path.join(&item.slug).join("index.html"), &self.inject_livereload(single_output) )?; } @@ -483,28 +378,31 @@ impl Site { /// What it says on the tin pub fn render_sitemap(&self) -> Result<()> { - self.ensure_public_directory_exists()?; + ensure_directory_exists(&self.output_path)?; + let mut context = Context::new(); context.add("pages", &self.pages.values().collect::>()); context.add("sections", &self.sections.values().collect::>()); let mut categories = vec![]; - if self.config.generate_categories_pages.unwrap() && !self.categories.is_empty() { - categories.push(self.config.make_permalink("categories")); - for category in self.categories.keys() { + if let Some(ref c) = self.categories { + let name = c.get_list_name(); + categories.push(self.config.make_permalink(&name)); + for item in &c.items { categories.push( - self.config.make_permalink(&format!("categories/{}", slugify(category))) + self.config.make_permalink(&format!("{}/{}", &name, item.slug)) ); } } context.add("categories", &categories); let mut tags = vec![]; - if self.config.generate_tags_pages.unwrap() && !self.tags.is_empty() { - tags.push(self.config.make_permalink("tags")); - for tag in self.tags.keys() { + if let Some(ref t) = self.tags { + let name = t.get_list_name(); + tags.push(self.config.make_permalink(&name)); + for item in &t.items { tags.push( - self.config.make_permalink(&format!("tags/{}", slugify(tag))) + self.config.make_permalink(&format!("{}/{}", &name, item.slug)) ); } } @@ -518,7 +416,7 @@ impl Site { } pub fn render_rss_feed(&self) -> Result<()> { - self.ensure_public_directory_exists()?; + ensure_directory_exists(&self.output_path)?; let mut context = Context::new(); let pages = self.pages.values() @@ -561,7 +459,7 @@ impl Site { /// Renders a single section pub fn render_section(&self, section: &Section, render_pages: bool) -> Result<()> { - self.ensure_public_directory_exists()?; + ensure_directory_exists(&self.output_path)?; let public = self.output_path.clone(); let mut output_path = public.to_path_buf(); @@ -611,7 +509,7 @@ impl Site { /// Renders all pages that do not belong to any sections pub fn render_orphan_pages(&self) -> Result<()> { - self.ensure_public_directory_exists()?; + ensure_directory_exists(&self.output_path)?; for page in self.get_all_orphan_pages() { self.render_page(page)?; @@ -622,7 +520,7 @@ impl Site { /// Renders a list of pages when the section/index is wanting pagination. fn render_paginated(&self, output_path: &Path, section: &Section) -> Result<()> { - self.ensure_public_directory_exists()?; + ensure_directory_exists(&self.output_path)?; let paginate_path = match section.meta.paginate_path { Some(ref s) => s.clone(), diff --git a/test_site/templates/categories.html b/test_site/templates/categories.html index 9ac110e..5981345 100644 --- a/test_site/templates/categories.html +++ b/test_site/templates/categories.html @@ -1,3 +1,3 @@ {% for category in categories %} - {{ category.name }} {{ category.slug }} {{ category.count }} + {{ category.name }} {{ category.slug }} {{ category.pages | length }} {% endfor %} diff --git a/test_site/templates/category.html b/test_site/templates/category.html index eaa13fe..842f6e2 100644 --- a/test_site/templates/category.html +++ b/test_site/templates/category.html @@ -1,7 +1,7 @@ -Category: {{ category }} +Category: {{ category.name }} -{% for page in pages %} +{% for page in category.pages %} diff --git a/test_site/templates/tag.html b/test_site/templates/tag.html index c77f0b0..896ed28 100644 --- a/test_site/templates/tag.html +++ b/test_site/templates/tag.html @@ -1,6 +1,6 @@ -Tag: {{ tag }} +Tag: {{ tag.name }} -{% for page in pages %} +{% for page in tag.pages %} diff --git a/test_site/templates/tags.html b/test_site/templates/tags.html index 8a0b254..a168c47 100644 --- a/test_site/templates/tags.html +++ b/test_site/templates/tags.html @@ -1,3 +1,3 @@ {% for tag in tags %} - {{ tag.name }} {{ tag.slug }} {{ tag.count }} + {{ tag.name }} {{ tag.slug }} {{ tag.pages | length }} {% endfor %} diff --git a/tests/site.rs b/tests/site.rs index 2c4fc3a..8e40806 100644 --- a/tests/site.rs +++ b/tests/site.rs @@ -190,7 +190,7 @@ fn can_build_site_with_categories() { site.build().unwrap(); assert!(Path::new(&public).exists()); - assert_eq!(site.categories.len(), 2); + assert_eq!(site.categories.unwrap().len(), 2); assert!(file_exists!(public, "index.html")); assert!(file_exists!(public, "sitemap.xml")); @@ -243,7 +243,7 @@ fn can_build_site_with_tags() { site.build().unwrap(); assert!(Path::new(&public).exists()); - assert_eq!(site.tags.len(), 3); + assert_eq!(site.tags.unwrap().len(), 3); assert!(file_exists!(public, "index.html")); assert!(file_exists!(public, "sitemap.xml"));