You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

796 lines
28KB

  1. extern crate tera;
  2. extern crate rayon;
  3. extern crate glob;
  4. extern crate walkdir;
  5. extern crate serde;
  6. #[macro_use]
  7. extern crate serde_derive;
  8. extern crate sass_rs;
  9. #[macro_use]
  10. extern crate errors;
  11. extern crate config;
  12. extern crate utils;
  13. extern crate front_matter;
  14. extern crate templates;
  15. extern crate pagination;
  16. extern crate taxonomies;
  17. extern crate content;
  18. #[cfg(test)]
  19. extern crate tempdir;
  20. use std::collections::HashMap;
  21. use std::fs::{remove_dir_all, copy, create_dir_all};
  22. use std::mem;
  23. use std::path::{Path, PathBuf};
  24. use glob::glob;
  25. use tera::{Tera, Context};
  26. use walkdir::WalkDir;
  27. use sass_rs::{Options, compile_file};
  28. use errors::{Result, ResultExt};
  29. use config::{Config, get_config};
  30. use utils::fs::{create_file, create_directory, ensure_directory_exists};
  31. use utils::templates::{render_template, rewrite_theme_paths};
  32. use content::{Page, Section, populate_previous_and_next_pages, sort_pages};
  33. use templates::{GUTENBERG_TERA, global_fns, render_redirect_template};
  34. use front_matter::{SortBy, InsertAnchor};
  35. use taxonomies::Taxonomy;
  36. use pagination::Paginator;
  37. use rayon::prelude::*;
  38. /// The sitemap only needs links and potentially date so we trim down
  39. /// all pages to only that
  40. #[derive(Debug, Serialize)]
  41. struct SitemapEntry {
  42. permalink: String,
  43. date: Option<String>,
  44. }
  45. impl SitemapEntry {
  46. pub fn new(permalink: String, date: Option<String>) -> SitemapEntry {
  47. SitemapEntry { permalink, date }
  48. }
  49. }
  50. #[derive(Debug)]
  51. pub struct Site {
  52. /// The base path of the gutenberg site
  53. pub base_path: PathBuf,
  54. /// The parsed config for the site
  55. pub config: Config,
  56. pub pages: HashMap<PathBuf, Page>,
  57. pub sections: HashMap<PathBuf, Section>,
  58. pub tera: Tera,
  59. live_reload: bool,
  60. output_path: PathBuf,
  61. pub static_path: PathBuf,
  62. pub tags: Option<Taxonomy>,
  63. pub categories: Option<Taxonomy>,
  64. /// A map of all .md files (section and pages) and their permalink
  65. /// We need that if there are relative links in the content that need to be resolved
  66. pub permalinks: HashMap<String, String>,
  67. }
  68. impl Site {
  69. /// Parse a site at the given path. Defaults to the current dir
  70. /// Passing in a path is only used in tests
  71. pub fn new<P: AsRef<Path>>(path: P, config_file: &str) -> Result<Site> {
  72. let path = path.as_ref();
  73. let mut config = get_config(path, config_file);
  74. let tpl_glob = format!("{}/{}", path.to_string_lossy().replace("\\", "/"), "templates/**/*.*ml");
  75. // Only parsing as we might be extending templates from themes and that would error
  76. // as we haven't loaded them yet
  77. let mut tera = Tera::parse(&tpl_glob).chain_err(|| "Error parsing templates")?;
  78. if let Some(theme) = config.theme.clone() {
  79. // Grab data from the extra section of the theme
  80. config.merge_with_theme(&path.join("themes").join(&theme).join("theme.toml"))?;
  81. // Test that the {templates,static} folder exist for that theme
  82. let theme_path = path.join("themes").join(&theme);
  83. if !theme_path.join("templates").exists() {
  84. bail!("Theme `{}` is missing a templates folder", theme);
  85. }
  86. if !theme_path.join("static").exists() {
  87. bail!("Theme `{}` is missing a static folder", theme);
  88. }
  89. let theme_tpl_glob = format!("{}/{}", path.to_string_lossy().replace("\\", "/"), "themes/**/*.html");
  90. let mut tera_theme = Tera::parse(&theme_tpl_glob).chain_err(|| "Error parsing templates from themes")?;
  91. rewrite_theme_paths(&mut tera_theme, &theme);
  92. tera_theme.build_inheritance_chains()?;
  93. tera.extend(&tera_theme)?;
  94. }
  95. tera.extend(&GUTENBERG_TERA)?;
  96. // the `extend` above already does it but hey
  97. tera.build_inheritance_chains()?;
  98. let site = Site {
  99. base_path: path.to_path_buf(),
  100. config: config,
  101. pages: HashMap::new(),
  102. sections: HashMap::new(),
  103. tera: tera,
  104. live_reload: false,
  105. output_path: path.join("public"),
  106. static_path: path.join("static"),
  107. tags: None,
  108. categories: None,
  109. permalinks: HashMap::new(),
  110. };
  111. Ok(site)
  112. }
  113. /// What the function name says
  114. pub fn enable_live_reload(&mut self) {
  115. self.live_reload = true;
  116. }
  117. /// Get all the orphan (== without section) pages in the site
  118. pub fn get_all_orphan_pages(&self) -> Vec<&Page> {
  119. let mut pages_in_sections = vec![];
  120. let mut orphans = vec![];
  121. for s in self.sections.values() {
  122. pages_in_sections.extend(s.all_pages_path());
  123. }
  124. for page in self.pages.values() {
  125. if !pages_in_sections.contains(&page.file.path) {
  126. orphans.push(page);
  127. }
  128. }
  129. orphans
  130. }
  131. /// Used by tests to change the output path to a tmp dir
  132. #[doc(hidden)]
  133. pub fn set_output_path<P: AsRef<Path>>(&mut self, path: P) {
  134. self.output_path = path.as_ref().to_path_buf();
  135. }
  136. /// Reads all .md files in the `content` directory and create pages/sections
  137. /// out of them
  138. pub fn load(&mut self) -> Result<()> {
  139. let base_path = self.base_path.to_string_lossy().replace("\\", "/");
  140. let content_glob = format!("{}/{}", base_path, "content/**/*.md");
  141. let (section_entries, page_entries): (Vec<_>, Vec<_>) = glob(&content_glob)
  142. .unwrap()
  143. .filter_map(|e| e.ok())
  144. .partition(|entry| entry.as_path().file_name().unwrap() == "_index.md");
  145. let sections = {
  146. let config = &self.config;
  147. section_entries
  148. .into_par_iter()
  149. .filter(|entry| entry.as_path().file_name().unwrap() == "_index.md")
  150. .map(|entry| {
  151. let path = entry.as_path();
  152. Section::from_file(path, config)
  153. })
  154. .collect::<Vec<_>>()
  155. };
  156. let pages = {
  157. let config = &self.config;
  158. page_entries
  159. .into_par_iter()
  160. .filter(|entry| entry.as_path().file_name().unwrap() != "_index.md")
  161. .map(|entry| {
  162. let path = entry.as_path();
  163. Page::from_file(path, config)
  164. })
  165. .collect::<Vec<_>>()
  166. };
  167. // Kinda duplicated code for add_section/add_page but necessary to do it that
  168. // way because of the borrow checker
  169. for section in sections {
  170. let s = section?;
  171. self.add_section(s, false)?;
  172. }
  173. // Insert a default index section if necessary so we don't need to create
  174. // a _index.md to render the index page
  175. let index_path = self.base_path.join("content").join("_index.md");
  176. if !self.sections.contains_key(&index_path) {
  177. let mut index_section = Section::default();
  178. index_section.permalink = self.config.make_permalink("");
  179. // TODO: need to insert into permalinks too
  180. self.sections.insert(index_path, index_section);
  181. }
  182. let mut pages_insert_anchors = HashMap::new();
  183. for page in pages {
  184. let p = page?;
  185. pages_insert_anchors.insert(p.file.path.clone(), self.find_parent_section_insert_anchor(&p.file.parent.clone()));
  186. self.add_page(p, false)?;
  187. }
  188. {
  189. // Another silly thing needed to not borrow &self in parallel and
  190. // make the borrow checker happy
  191. let permalinks = &self.permalinks;
  192. let tera = &self.tera;
  193. let config = &self.config;
  194. self.pages.par_iter_mut()
  195. .map(|(_, page)| {
  196. let insert_anchor = pages_insert_anchors[&page.file.path];
  197. page.render_markdown(permalinks, tera, config, insert_anchor)
  198. })
  199. .fold(|| Ok(()), Result::and)
  200. .reduce(|| Ok(()), Result::and)?;
  201. self.sections.par_iter_mut()
  202. .map(|(_, section)| section.render_markdown(permalinks, tera, config))
  203. .fold(|| Ok(()), Result::and)
  204. .reduce(|| Ok(()), Result::and)?;
  205. }
  206. self.populate_sections();
  207. self.populate_tags_and_categories();
  208. self.register_tera_global_fns();
  209. Ok(())
  210. }
  211. pub fn register_tera_global_fns(&mut self) {
  212. self.tera.register_global_function("get_page", global_fns::make_get_page(&self.pages));
  213. self.tera.register_global_function("get_section", global_fns::make_get_section(&self.sections));
  214. self.tera.register_global_function(
  215. "get_url",
  216. global_fns::make_get_url(self.permalinks.clone(), self.config.clone())
  217. );
  218. }
  219. /// Add a page to the site
  220. /// The `render` parameter is used in the serve command, when rebuilding a page.
  221. /// If `true`, it will also render the markdown for that page
  222. /// Returns the previous page struct if there was one
  223. pub fn add_page(&mut self, page: Page, render: bool) -> Result<Option<Page>> {
  224. let path = page.file.path.clone();
  225. self.permalinks.insert(page.file.relative.clone(), page.permalink.clone());
  226. let prev = self.pages.insert(page.file.path.clone(), page);
  227. if render {
  228. let insert_anchor = self.find_parent_section_insert_anchor(&self.pages[&path].file.parent);
  229. let page = self.pages.get_mut(&path).unwrap();
  230. page.render_markdown(&self.permalinks, &self.tera, &self.config, insert_anchor)?;
  231. }
  232. Ok(prev)
  233. }
  234. /// Add a section to the site
  235. /// The `render` parameter is used in the serve command, when rebuilding a page.
  236. /// If `true`, it will also render the markdown for that page
  237. /// Returns the previous section struct if there was one
  238. pub fn add_section(&mut self, section: Section, render: bool) -> Result<Option<Section>> {
  239. let path = section.file.path.clone();
  240. self.permalinks.insert(section.file.relative.clone(), section.permalink.clone());
  241. let prev = self.sections.insert(section.file.path.clone(), section);
  242. if render {
  243. let section = self.sections.get_mut(&path).unwrap();
  244. section.render_markdown(&self.permalinks, &self.tera, &self.config)?;
  245. }
  246. Ok(prev)
  247. }
  248. /// Finds the insert_anchor for the parent section of the directory at `path`.
  249. /// Defaults to `AnchorInsert::None` if no parent section found
  250. pub fn find_parent_section_insert_anchor(&self, parent_path: &PathBuf) -> InsertAnchor {
  251. match self.sections.get(&parent_path.join("_index.md")) {
  252. Some(s) => s.meta.insert_anchor_links.unwrap(),
  253. None => InsertAnchor::None
  254. }
  255. }
  256. /// Find out the direct subsections of each subsection if there are some
  257. /// as well as the pages for each section
  258. pub fn populate_sections(&mut self) {
  259. let mut grandparent_paths: HashMap<PathBuf, Vec<PathBuf>> = HashMap::new();
  260. for section in self.sections.values_mut() {
  261. if let Some(ref grand_parent) = section.file.grand_parent {
  262. grandparent_paths
  263. .entry(grand_parent.to_path_buf())
  264. .or_insert_with(|| vec![])
  265. .push(section.file.path.clone());
  266. }
  267. // Make sure the pages of a section are empty since we can call that many times on `serve`
  268. section.pages = vec![];
  269. section.ignored_pages = vec![];
  270. }
  271. for page in self.pages.values() {
  272. let parent_section_path = page.file.parent.join("_index.md");
  273. if self.sections.contains_key(&parent_section_path) {
  274. self.sections.get_mut(&parent_section_path).unwrap().pages.push(page.clone());
  275. }
  276. }
  277. self.sort_sections_pages(None);
  278. // TODO: remove this clone
  279. let sections = self.sections.clone();
  280. for section in self.sections.values_mut() {
  281. if let Some(paths) = grandparent_paths.get(&section.file.parent) {
  282. section.subsections = paths
  283. .iter()
  284. .map(|p| sections[p].clone())
  285. .collect::<Vec<_>>();
  286. section.subsections
  287. .sort_by(|a, b| a.meta.weight.unwrap().cmp(&b.meta.weight.unwrap()));
  288. }
  289. }
  290. }
  291. /// Sorts the pages of the section at the given path
  292. /// By default will sort all sections but can be made to only sort a single one by providing a path
  293. pub fn sort_sections_pages(&mut self, only: Option<&Path>) {
  294. for (path, section) in &mut self.sections {
  295. if let Some(p) = only {
  296. if p != path {
  297. continue;
  298. }
  299. }
  300. let pages = mem::replace(&mut section.pages, vec![]);
  301. let (sorted_pages, cannot_be_sorted_pages) = sort_pages(pages, section.meta.sort_by());
  302. section.pages = populate_previous_and_next_pages(&sorted_pages);
  303. section.ignored_pages = cannot_be_sorted_pages;
  304. }
  305. }
  306. /// Find all the tags and categories if it's asked in the config
  307. pub fn populate_tags_and_categories(&mut self) {
  308. let generate_tags_pages = self.config.generate_tags_pages.unwrap();
  309. let generate_categories_pages = self.config.generate_categories_pages.unwrap();
  310. if !generate_tags_pages && !generate_categories_pages {
  311. return;
  312. }
  313. // TODO: can we pass a reference?
  314. let (tags, categories) = Taxonomy::find_tags_and_categories(
  315. &self.config,
  316. self.pages
  317. .values()
  318. .filter(|p| !p.is_draft())
  319. .cloned()
  320. .collect::<Vec<_>>()
  321. .as_slice()
  322. );
  323. if generate_tags_pages {
  324. self.tags = Some(tags);
  325. }
  326. if generate_categories_pages {
  327. self.categories = Some(categories);
  328. }
  329. }
  330. /// Inject live reload script tag if in live reload mode
  331. fn inject_livereload(&self, html: String) -> String {
  332. if self.live_reload {
  333. return html.replace(
  334. "</body>",
  335. r#"<script src="/livereload.js?port=1112&mindelay=10"></script></body>"#
  336. );
  337. }
  338. html
  339. }
  340. /// Copy the file at the given path into the public folder
  341. pub fn copy_static_file<P: AsRef<Path>>(&self, path: P, base_path: &PathBuf) -> Result<()> {
  342. let relative_path = path.as_ref().strip_prefix(base_path).unwrap();
  343. let target_path = self.output_path.join(relative_path);
  344. if let Some(parent_directory) = target_path.parent() {
  345. create_dir_all(parent_directory)?;
  346. }
  347. copy(path.as_ref(), &target_path)?;
  348. Ok(())
  349. }
  350. /// Copy the content of the given folder into the `public` folder
  351. fn copy_static_directory(&self, path: &PathBuf) -> Result<()> {
  352. for entry in WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
  353. let relative_path = entry.path().strip_prefix(path).unwrap();
  354. let target_path = self.output_path.join(relative_path);
  355. if entry.path().is_dir() {
  356. if !target_path.exists() {
  357. create_directory(&target_path)?;
  358. }
  359. } else {
  360. let entry_fullpath = self.base_path.join(entry.path());
  361. self.copy_static_file(entry_fullpath, path)?;
  362. }
  363. }
  364. Ok(())
  365. }
  366. /// Copy the main `static` folder and the theme `static` folder if a theme is used
  367. pub fn copy_static_directories(&self) -> Result<()> {
  368. // The user files will overwrite the theme files
  369. if let Some(ref theme) = self.config.theme {
  370. self.copy_static_directory(
  371. &self.base_path.join("themes").join(theme).join("static")
  372. )?;
  373. }
  374. self.copy_static_directory(&self.static_path)?;
  375. Ok(())
  376. }
  377. /// Deletes the `public` directory if it exists
  378. pub fn clean(&self) -> Result<()> {
  379. if self.output_path.exists() {
  380. // Delete current `public` directory so we can start fresh
  381. remove_dir_all(&self.output_path).chain_err(|| "Couldn't delete `public` directory")?;
  382. }
  383. Ok(())
  384. }
  385. /// Renders a single content page
  386. pub fn render_page(&self, page: &Page) -> Result<()> {
  387. ensure_directory_exists(&self.output_path)?;
  388. // Copy the nesting of the content directory if we have sections for that page
  389. let mut current_path = self.output_path.to_path_buf();
  390. for component in page.path.split('/') {
  391. current_path.push(component);
  392. if !current_path.exists() {
  393. create_directory(&current_path)?;
  394. }
  395. }
  396. // Make sure the folder exists
  397. create_directory(&current_path)?;
  398. // Finally, create a index.html file there with the page rendered
  399. let output = page.render_html(&self.tera, &self.config)?;
  400. create_file(&current_path.join("index.html"), &self.inject_livereload(output))?;
  401. // Copy any asset we found previously into the same directory as the index.html
  402. for asset in &page.assets {
  403. let asset_path = asset.as_path();
  404. copy(&asset_path, &current_path.join(asset_path.file_name().unwrap()))?;
  405. }
  406. Ok(())
  407. }
  408. /// Deletes the `public` directory and builds the site
  409. pub fn build(&self) -> Result<()> {
  410. self.clean()?;
  411. // Render aliases first to allow overwriting
  412. self.render_aliases()?;
  413. self.render_sections()?;
  414. self.render_orphan_pages()?;
  415. self.render_sitemap()?;
  416. if self.config.generate_rss.unwrap() {
  417. self.render_rss_feed()?;
  418. }
  419. self.render_robots()?;
  420. // `render_categories` and `render_tags` will check whether the config allows
  421. // them to render or not
  422. self.render_categories()?;
  423. self.render_tags()?;
  424. if let Some(ref theme) = self.config.theme {
  425. let theme_path = self.base_path.join("themes").join(theme);
  426. if theme_path.join("sass").exists() {
  427. self.compile_sass(&theme_path)?;
  428. }
  429. }
  430. if self.config.compile_sass.unwrap() {
  431. self.compile_sass(&self.base_path)?;
  432. }
  433. self.copy_static_directories()
  434. }
  435. pub fn compile_sass(&self, base_path: &PathBuf) -> Result<()> {
  436. ensure_directory_exists(&self.output_path)?;
  437. let base_path = base_path.to_string_lossy().replace("\\", "/");
  438. let sass_glob = format!("{}/{}", base_path, "sass/**/*.scss");
  439. let files = glob(&sass_glob)
  440. .unwrap()
  441. .filter_map(|e| e.ok())
  442. .filter(|entry| !entry.as_path().file_name().unwrap().to_string_lossy().starts_with('_'))
  443. .collect::<Vec<_>>();
  444. for file in files {
  445. let name = file.as_path().file_stem().unwrap().to_string_lossy();
  446. let css = match compile_file(file.as_path(), Options::default()) {
  447. Ok(c) => c,
  448. Err(e) => bail!(e)
  449. };
  450. create_file(&self.output_path.join(format!("{}.css", name)), &css)?;
  451. }
  452. Ok(())
  453. }
  454. pub fn render_aliases(&self) -> Result<()> {
  455. for page in self.pages.values() {
  456. if let Some(ref aliases) = page.meta.aliases {
  457. for alias in aliases {
  458. let mut output_path = self.output_path.to_path_buf();
  459. for component in alias.split('/') {
  460. output_path.push(&component);
  461. if !output_path.exists() {
  462. create_directory(&output_path)?;
  463. }
  464. }
  465. create_file(&output_path.join("index.html"), &render_redirect_template(&page.permalink, &self.tera)?)?;
  466. }
  467. }
  468. }
  469. Ok(())
  470. }
  471. /// Renders robots.txt
  472. pub fn render_robots(&self) -> Result<()> {
  473. ensure_directory_exists(&self.output_path)?;
  474. create_file(
  475. &self.output_path.join("robots.txt"),
  476. &render_template("robots.txt", &self.tera, &Context::new(), self.config.theme.clone())?
  477. )
  478. }
  479. /// Renders all categories and the single category pages if there are some
  480. pub fn render_categories(&self) -> Result<()> {
  481. if let Some(ref categories) = self.categories {
  482. self.render_taxonomy(categories)?;
  483. }
  484. Ok(())
  485. }
  486. /// Renders all tags and the single tag pages if there are some
  487. pub fn render_tags(&self) -> Result<()> {
  488. if let Some(ref tags) = self.tags {
  489. self.render_taxonomy(tags)?;
  490. }
  491. Ok(())
  492. }
  493. fn render_taxonomy(&self, taxonomy: &Taxonomy) -> Result<()> {
  494. if taxonomy.items.is_empty() {
  495. return Ok(())
  496. }
  497. ensure_directory_exists(&self.output_path)?;
  498. let output_path = self.output_path.join(&taxonomy.get_list_name());
  499. let list_output = taxonomy.render_list(&self.tera, &self.config)?;
  500. create_directory(&output_path)?;
  501. create_file(&output_path.join("index.html"), &self.inject_livereload(list_output))?;
  502. taxonomy
  503. .items
  504. .par_iter()
  505. .map(|item| {
  506. let single_output = taxonomy.render_single_item(item, &self.tera, &self.config)?;
  507. create_directory(&output_path.join(&item.slug))?;
  508. create_file(
  509. &output_path.join(&item.slug).join("index.html"),
  510. &self.inject_livereload(single_output)
  511. )
  512. })
  513. .fold(|| Ok(()), Result::and)
  514. .reduce(|| Ok(()), Result::and)
  515. }
  516. /// What it says on the tin
  517. pub fn render_sitemap(&self) -> Result<()> {
  518. ensure_directory_exists(&self.output_path)?;
  519. let mut context = Context::new();
  520. context.add(
  521. "pages",
  522. &self.pages
  523. .values()
  524. .filter(|p| !p.is_draft())
  525. .map(|p| SitemapEntry::new(p.permalink.clone(), p.meta.date.clone()))
  526. .collect::<Vec<_>>()
  527. );
  528. context.add(
  529. "sections",
  530. &self.sections
  531. .values()
  532. .map(|s| SitemapEntry::new(s.permalink.clone(), None))
  533. .collect::<Vec<_>>()
  534. );
  535. let mut categories = vec![];
  536. if let Some(ref c) = self.categories {
  537. let name = c.get_list_name();
  538. categories.push(SitemapEntry::new(self.config.make_permalink(&name), None));
  539. for item in &c.items {
  540. categories.push(
  541. SitemapEntry::new(self.config.make_permalink(&format!("{}/{}", &name, item.slug)), None),
  542. );
  543. }
  544. }
  545. context.add("categories", &categories);
  546. let mut tags = vec![];
  547. if let Some(ref t) = self.tags {
  548. let name = t.get_list_name();
  549. tags.push(SitemapEntry::new(self.config.make_permalink(&name), None));
  550. for item in &t.items {
  551. tags.push(
  552. SitemapEntry::new(self.config.make_permalink(&format!("{}/{}", &name, item.slug)), None),
  553. );
  554. }
  555. }
  556. context.add("tags", &tags);
  557. context.add("config", &self.config);
  558. let sitemap = &render_template("sitemap.xml", &self.tera, &context, self.config.theme.clone())?;
  559. create_file(&self.output_path.join("sitemap.xml"), sitemap)?;
  560. Ok(())
  561. }
  562. pub fn render_rss_feed(&self) -> Result<()> {
  563. ensure_directory_exists(&self.output_path)?;
  564. let mut context = Context::new();
  565. let pages = self.pages.values()
  566. .filter(|p| p.meta.date.is_some() && !p.is_draft())
  567. .cloned()
  568. .collect::<Vec<Page>>();
  569. // Don't generate a RSS feed if none of the pages has a date
  570. if pages.is_empty() {
  571. return Ok(());
  572. }
  573. let (sorted_pages, _) = sort_pages(pages, SortBy::Date);
  574. context.add("last_build_date", &sorted_pages[0].meta.date);
  575. // limit to the last n elements)
  576. context.add("pages", &sorted_pages.iter().take(self.config.rss_limit.unwrap()).collect::<Vec<_>>());
  577. context.add("config", &self.config);
  578. let rss_feed_url = if self.config.base_url.ends_with('/') {
  579. format!("{}{}", self.config.base_url, "rss.xml")
  580. } else {
  581. format!("{}/{}", self.config.base_url, "rss.xml")
  582. };
  583. context.add("feed_url", &rss_feed_url);
  584. let feed = &render_template("rss.xml", &self.tera, &context, self.config.theme.clone())?;
  585. create_file(&self.output_path.join("rss.xml"), feed)?;
  586. Ok(())
  587. }
  588. /// Renders a single section
  589. pub fn render_section(&self, section: &Section, render_pages: bool) -> Result<()> {
  590. ensure_directory_exists(&self.output_path)?;
  591. let public = self.output_path.clone();
  592. let mut output_path = public.to_path_buf();
  593. for component in &section.file.components {
  594. output_path.push(component);
  595. if !output_path.exists() {
  596. create_directory(&output_path)?;
  597. }
  598. }
  599. if render_pages {
  600. section
  601. .pages
  602. .par_iter()
  603. .map(|p| self.render_page(p))
  604. .fold(|| Ok(()), Result::and)
  605. .reduce(|| Ok(()), Result::and)?;
  606. }
  607. if !section.meta.should_render() {
  608. return Ok(());
  609. }
  610. if let Some(ref redirect_to) = section.meta.redirect_to {
  611. let permalink = self.config.make_permalink(redirect_to);
  612. create_file(&output_path.join("index.html"), &render_redirect_template(&permalink, &self.tera)?)?;
  613. return Ok(());
  614. }
  615. if section.meta.is_paginated() {
  616. self.render_paginated(&output_path, section)?;
  617. } else {
  618. let output = section.render_html(&self.tera, &self.config)?;
  619. create_file(&output_path.join("index.html"), &self.inject_livereload(output))?;
  620. }
  621. Ok(())
  622. }
  623. pub fn render_index(&self) -> Result<()> {
  624. self.render_section(&self.sections[&self.base_path.join("content").join("_index.md")], false)
  625. }
  626. /// Renders all sections
  627. pub fn render_sections(&self) -> Result<()> {
  628. self.sections
  629. .values()
  630. .collect::<Vec<_>>()
  631. .into_par_iter()
  632. .map(|s| self.render_section(s, true))
  633. .fold(|| Ok(()), Result::and)
  634. .reduce(|| Ok(()), Result::and)
  635. }
  636. /// Renders all pages that do not belong to any sections
  637. pub fn render_orphan_pages(&self) -> Result<()> {
  638. ensure_directory_exists(&self.output_path)?;
  639. for page in self.get_all_orphan_pages() {
  640. self.render_page(page)?;
  641. }
  642. Ok(())
  643. }
  644. /// Renders a list of pages when the section/index is wanting pagination.
  645. pub fn render_paginated(&self, output_path: &Path, section: &Section) -> Result<()> {
  646. ensure_directory_exists(&self.output_path)?;
  647. let paginate_path = match section.meta.paginate_path {
  648. Some(ref s) => s.clone(),
  649. None => unreachable!()
  650. };
  651. let paginator = Paginator::new(&section.pages, section);
  652. let folder_path = output_path.join(&paginate_path);
  653. create_directory(&folder_path)?;
  654. paginator
  655. .pagers
  656. .par_iter()
  657. .enumerate()
  658. .map(|(i, pager)| {
  659. let page_path = folder_path.join(&format!("{}", i + 1));
  660. create_directory(&page_path)?;
  661. let output = paginator.render_pager(pager, &self.config, &self.tera)?;
  662. if i > 0 {
  663. create_file(&page_path.join("index.html"), &self.inject_livereload(output))?;
  664. } else {
  665. create_file(&output_path.join("index.html"), &self.inject_livereload(output))?;
  666. create_file(&page_path.join("index.html"), &render_redirect_template(&section.permalink, &self.tera)?)?;
  667. }
  668. Ok(())
  669. })
  670. .fold(|| Ok(()), Result::and)
  671. .reduce(|| Ok(()), Result::and)
  672. }
  673. }