Render simple section IDs and numbers

5 files changed, 126 insertions, 84 deletions

diff --git a/src/document_tree.rs b/src/document_tree.rs
index 3d983da..0af47ba 100644
--- a/src/document_tree.rs
+++ b/src/document_tree.rs
@@ -9,7 +9,7 @@ pub mod element_categories;
 pub mod extra_attributes;
 pub mod attribute_types;
 
-pub use self::elements::*; //Element,CommonAttributes,
+pub use self::elements::*; //Element,CommonAttributes,HasExtraAndChildren
 pub use self::extra_attributes::ExtraAttributes;
 pub use self::element_categories::HasChildren;
 
diff --git a/src/parser/conversion.rs b/src/parser/conversion.rs
index 32461bf..f9e2a78 100644
--- a/src/parser/conversion.rs
+++ b/src/parser/conversion.rs
@@ -5,9 +5,10 @@ use failure::Error;
 use pest::iterators::Pairs;
 
 use crate::document_tree::{
-	HasChildren,
+	Element,HasChildren,
 	elements as e,
 	element_categories as c,
+	attribute_types as at,
 };
 
 use super::pest_rst::Rule;
@@ -63,7 +64,10 @@ pub fn convert_document(pairs: Pairs<Rule>) -> Result<e::Document, Error> {
 					None => kinds.push(kind),
 				}
 				let super_level = get_level(&mut toplevel, &section_idxs);
-				super_level.push(e::Section::with_children(vec![title.into()]).into());
+				let slug = title.names().iter().next().map(|at::NameToken(name)| at::ID(name.to_owned()));
+				let mut section = e::Section::with_children(vec![title.into()]);
+				section.ids_mut().extend(slug.into_iter());
+				super_level.push(section.into());
 				section_idxs.push(Some(super_level.len() - 1));
 			},
 			Ssubel(elem) => get_level(&mut toplevel, &section_idxs).push(elem),
diff --git a/src/parser/conversion/block.rs b/src/parser/conversion/block.rs
index 1e5d88f..b14c2b5 100644
--- a/src/parser/conversion/block.rs
+++ b/src/parser/conversion/block.rs
@@ -29,7 +29,7 @@ pub(super) fn convert_ssubel(pair: Pair<Rule>) -> Result<Option<TitleOrSsubel>,
 	use self::TitleOrSsubel::*;
 	Ok(Some(match pair.as_rule() {
 		Rule::title => { let (t, k) = convert_title(pair)?; Title(t, k) },
-		//TODO: subtitle, dectoration, docinfo
+		//TODO: subtitle, decoration, docinfo
 		Rule::EOI   => return Ok(None),
 		_           => Ssubel(convert_substructure(pair)?.into()),
 	}))
@@ -38,7 +38,8 @@ pub(super) fn convert_ssubel(pair: Pair<Rule>) -> Result<Option<TitleOrSsubel>,
 
 fn convert_substructure(pair: Pair<Rule>) -> Result<c::SubStructure, Error> {
 	Ok(match pair.as_rule() {
-		// todo: Topic, Sidebar, Transition, Section
+		// todo: Topic, Sidebar, Transition
+		// no section here, as it’s constructed from titles
 		_ => convert_body_elem(pair)?.into(),
 	})
 }
@@ -58,21 +59,30 @@ fn convert_body_elem(pair: Pair<Rule>) -> Result<c::BodyElement, Error> {
 
 
 fn convert_title(pair: Pair<Rule>) -> Result<(e::Title, TitleKind), Error> {
-	let mut title: Option<Vec<c::TextOrInlineElement>> = None;
+	let mut title: Option<String> = None;
+	let mut title_inlines: Option<Vec<c::TextOrInlineElement>> = None;
 	let mut adornment_char: Option<char> = None;
 	// title_double or title_single. Extract kind before consuming
 	let inner_pair = pair.into_inner().next().unwrap();
 	let kind = inner_pair.as_rule();
 	for p in inner_pair.into_inner() {
 		match p.as_rule() {
-			Rule::line => title = Some(convert_inlines(p)?),
+			Rule::line => {
+				title = Some(p.as_str().to_owned());
+				title_inlines = Some(convert_inlines(p)?);
+			},
 			Rule::adornments => adornment_char = Some(p.as_str().chars().next().expect("Empty adornment?")),
 			rule => unimplemented!("Unexpected rule in title: {:?}", rule),
 		};
 	}
 	// now we encountered one line of text and one of adornments
 	// TODO: emit error if the adornment line is too short (has to match title length)
-	let elem = e::Title::with_children(title.expect("No text in title"));
+	let mut elem = e::Title::with_children(title_inlines.expect("No text in title"));
+	if let Some(title) = title {
+		//TODO: slugify properly
+		let slug =  title.to_lowercase().replace("\n", "").replace(" ", "-");
+		elem.names_mut().push(at::NameToken(slug));
+	}
 	let title_kind = match kind {
 		Rule::title_double => TitleKind::Double(adornment_char.unwrap()),
 		Rule::title_single => TitleKind::Single(adornment_char.unwrap()),
diff --git a/src/parser/conversion/inline.rs b/src/parser/conversion/inline.rs
index bdabbf0..52803ef 100644
--- a/src/parser/conversion/inline.rs
+++ b/src/parser/conversion/inline.rs
@@ -2,11 +2,11 @@ use failure::Error;
 use pest::iterators::Pair;
 
 use crate::document_tree::{
+	HasChildren,
 	elements as e,
 	element_categories as c,
 	extra_attributes as a,
 	attribute_types as at,
-	element_categories::HasChildren,
 };
 
 use crate::parser::{
diff --git a/src/renderer/html.rs b/src/renderer/html.rs
index 1bc85c0..69a4430 100644
--- a/src/renderer/html.rs
+++ b/src/renderer/html.rs
@@ -1,12 +1,10 @@
 use std::io::Write;
 
-use failure::Error;
+use failure::{Error, Fail};
 
 // use crate::url::Url;
 use crate::document_tree::{
-	Document,
-	HasChildren,
-	ExtraAttributes,
+	Document,Element,HasChildren,ExtraAttributes,
 	elements as e,
 	element_categories as c,
 	extra_attributes as a,
@@ -15,14 +13,14 @@ use crate::document_tree::{
 
 // static FOOTNOTE_SYMBOLS: [char; 10] = ['*', '†', '‡', '§', '¶', '#', '♠', '♥', '♦', '♣'];
 
-pub fn render_html<W>(document: &Document, mut stream: W, standalone: bool) -> Result<(), Error> where W: Write {
+pub fn render_html<W>(document: &Document, stream: W, standalone: bool) -> Result<(), Error> where W: Write {
+	let mut renderer = HTMLRenderer { stream, level: 0 };
 	if standalone {
-		document.render_html(stream.by_ref())
+		document.render_html(&mut renderer)
 	} else {
-		let stream = stream.by_ref();
 		for c in document.children() {
-			(*c).render_html(stream)?;
-			writeln!(stream)?;
+			(*c).render_html(&mut renderer)?;
+			writeln!(renderer.stream)?;
 		}
 		Ok(())
 	}
@@ -35,15 +33,20 @@ fn escape_html(text: &str) -> String {
 		.replace('"', "&quot;")
 }
 
+struct HTMLRenderer<W> where W: Write {
+	stream: W,
+	level: u8,
+}
+
 trait HTMLRender {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write;
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write;
 }
 
 macro_rules! impl_html_render_cat {($cat:ident { $($member:ident),+ }) => {
 	impl HTMLRender for c::$cat {
-		fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
+		fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 			match self {$(
-				c::$cat::$member(elem) => (**elem).render_html(stream),
+				c::$cat::$member(elem) => (**elem).render_html(renderer),
 			)+}
 		}
 	}
@@ -62,15 +65,15 @@ macro_rules! impl_html_render_simple {
 	};
 	( $type:ident => $tag:ident [ $post:expr ] ) => {
 		impl HTMLRender for e::$type {
-			fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
+			fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 				let multiple_children = self.children().len() > 1;
-				write!(stream, "<{}>", stringify!($tag))?;
-				if multiple_children { write!(stream, $post)?; }
+				write!(renderer.stream, "<{}>", stringify!($tag))?;
+				if multiple_children { write!(renderer.stream, $post)?; }
 				for c in self.children() {
-					(*c).render_html(stream)?;
-					if multiple_children { write!(stream, $post)?; }
+					(*c).render_html(renderer)?;
+					if multiple_children { write!(renderer.stream, $post)?; }
 				}
-				write!(stream, "</{}>", stringify!($tag))?;
+				write!(renderer.stream, "</{}>", stringify!($tag))?;
 				Ok(())
 			}
 		}
@@ -79,8 +82,8 @@ macro_rules! impl_html_render_simple {
 
 macro_rules! impl_html_render_simple_nochildren {( $($type:ident => $tag:ident),+ ) => { $(
 	impl HTMLRender for e::$type {
-		fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
-			write!(stream, "<{0}></{0}>", stringify!($tag))?;
+		fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+			write!(renderer.stream, "<{0}></{0}>", stringify!($tag))?;
 			Ok(())
 		}
 	}
@@ -89,46 +92,71 @@ macro_rules! impl_html_render_simple_nochildren {( $($type:ident => $tag:ident),
 // Impl
 
 impl HTMLRender for Document {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
-		writeln!(stream, "<!doctype html><html>")?;
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+		writeln!(renderer.stream, "<!doctype html><html>")?;
 		for c in self.children() {
-			(*c).render_html(stream)?;
-			writeln!(stream)?;
+			(*c).render_html(renderer)?;
+			writeln!(renderer.stream)?;
 		}
-		writeln!(stream, "</html>")?;
+		writeln!(renderer.stream, "</html>")?;
 		Ok(())
 	}
 }
 
 impl_html_render_cat!(StructuralSubElement { Title, Subtitle, Decoration, Docinfo, SubStructure });
-impl_html_render_simple!(Title => h1, Subtitle => h2);
+impl_html_render_simple!(Subtitle => h2);
+
+impl HTMLRender for e::Title {
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+		let level = if renderer.level > 6 { 6 } else { renderer.level };
+		write!(renderer.stream, "<h{0}>", level)?;
+		for c in self.children() {
+			(*c).render_html(renderer)?;
+		}
+		write!(renderer.stream, "</h{0}>", level)?;
+		Ok(())
+	}
+}
 
 impl HTMLRender for e::Docinfo {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Like “YAML frontmatter” in Markdown
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::Decoration {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Header or footer
 		unimplemented!();
 	}
 }
 
 impl_html_render_cat!(SubStructure { Topic, Sidebar, Transition, Section, BodyElement });
-impl_html_render_simple!(Sidebar => aside, Section => section["\n"]);
+impl_html_render_simple!(Sidebar => aside);
+
+impl HTMLRender for e::Section {
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+		renderer.level += 1;
+		writeln!(renderer.stream, "<section id=\"{0}\">", self.ids()[0].0)?;
+		for c in self.children() {
+			(*c).render_html(renderer)?;
+			writeln!(renderer.stream)?;
+		}
+		write!(renderer.stream, "</section>")?;
+		Ok(())
+	}
+}
 
 impl HTMLRender for e::Transition {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
-		write!(stream, "<hr/>")?;
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+		write!(renderer.stream, "<hr/>")?;
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::Topic {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// A mini section with title
 		unimplemented!();
 	}
@@ -139,94 +167,94 @@ impl_html_render_simple!(Paragraph => p, LiteralBlock => pre, MathBlock => math,
 impl_html_render_simple_nochildren!(Table => table);  //TODO: after implementing the table, move it to elems with children
 
 impl<I> HTMLRender for I where I: e::Element + a::ExtraAttributes<a::Image> {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		let extra = self.extra();
 		if let Some(ref target) = extra.target {
-			write!(stream, "<a href=\"{}\">", escape_html(target.as_str()))?;
+			write!(renderer.stream, "<a href=\"{}\">", escape_html(target.as_str()))?;
 		}
-		write!(stream, "<img")?;
+		write!(renderer.stream, "<img")?;
 		if let Some(ref alt) = extra.alt {
-			write!(stream, " alt=\"{}\"", escape_html(alt))?;
+			write!(renderer.stream, " alt=\"{}\"", escape_html(alt))?;
 		}
 		// TODO: align: Option<AlignHV>
 		// TODO: height: Option<Measure>
 		// TODO: width: Option<Measure>
 		// TODO: scale: Option<u8>
-		write!(stream, " src=\"{}\" />", escape_html(extra.uri.as_str()))?;
+		write!(renderer.stream, " src=\"{}\" />", escape_html(extra.uri.as_str()))?;
 		if extra.target.is_some() {
-			write!(stream, "</a>")?;
+			write!(renderer.stream, "</a>")?;
 		}
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::DoctestBlock {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// TODO
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::SubstitutionDefinition {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// TODO: Should those be removed after resolving them
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::Comment {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
-		write!(stream, "<!--")?;
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+		write!(renderer.stream, "<!--")?;
 		for c in self.children() {
-			(*c).render_html(stream)?;
+			(*c).render_html(renderer)?;
 		}
-		write!(stream, "-->")?;
+		write!(renderer.stream, "-->")?;
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::Pending {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Will those be resolved by the time we get here?
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::Target {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Should be resolved by now
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::Raw {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		for c in self.children() {
-			write!(stream, "{}", c)?;
+			write!(renderer.stream, "{}", c)?;
 		}
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::Footnote {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::Citation {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::SystemMessage {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
-		write!(stream, "<figure><caption>System Message</caption>")?;
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+		write!(renderer.stream, "<figure><caption>System Message</caption>")?;
 		for c in self.children() {
-			(*c).render_html(stream)?;
+			(*c).render_html(renderer)?;
 		}
-		write!(stream, "</figure>")?;
+		write!(renderer.stream, "</figure>")?;
 		Ok(())
 	}
 }
@@ -235,58 +263,58 @@ impl_html_render_cat!(TextOrInlineElement { String, Emphasis, Strong, Literal, R
 impl_html_render_simple!(Emphasis => em, Strong => strong, Literal => code, FootnoteReference => a, CitationReference => a, TitleReference => a, Abbreviation => abbr, Acronym => acronym, Superscript => sup, Subscript => sub, Inline => span, Math => math, TargetInline => a);
 
 impl HTMLRender for String {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
-		write!(stream, "{}", escape_html(self))?;
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+		write!(renderer.stream, "{}", escape_html(self))?;
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::Reference {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		let extra = self.extra();
-		write!(stream, "<a")?;
+		write!(renderer.stream, "<a")?;
 		if let Some(ref target) = extra.refuri {
-			write!(stream, " href=\"{}\"", escape_html(target.as_str()))?;
+			write!(renderer.stream, " href=\"{}\"", escape_html(target.as_str()))?;
 		}
 		/*
 		if let Some(ref name) = extra.name {
-			write!(stream, " title=\"{}\"", escape_html(&name.0))?;
+			write!(renderer.stream, " title=\"{}\"", escape_html(&name.0))?;
 		}
 		*/
-		write!(stream, ">")?;
+		write!(renderer.stream, ">")?;
 		for c in self.children() {
-			(*c).render_html(stream)?;
+			(*c).render_html(renderer)?;
 		}
-		write!(stream, "</a>")?;
+		write!(renderer.stream, "</a>")?;
 		Ok(())
 	}
 }
 
 impl HTMLRender for e::SubstitutionReference {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Will those be resolved by the time we get here?
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::Problematic {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Broken inline markup leads to insertion of this in docutils
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::Generated {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Section numbers and so on
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::RawInline {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		for c in self.children() {
-			write!(stream, "{}", c)?;
+			write!(renderer.stream, "{}", c)?;
 		}
 		Ok(())
 	}
@@ -302,21 +330,21 @@ impl_html_render_cat!(SubSidebar { Topic, Title, Subtitle, BodyElement });
 impl_html_render_simple!(ListItem => li);
 
 impl HTMLRender for e::DefinitionListItem {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// Term→dt, Definition→dd, Classifier→???
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::Field {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// FieldName→dt, FieldBody→dd
 		unimplemented!();
 	}
 }
 
 impl HTMLRender for e::OptionListItem {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		// OptionGroup→dt(s), Description→dd
 		unimplemented!();
 	}
@@ -325,11 +353,11 @@ impl HTMLRender for e::OptionListItem {
 impl_html_render_cat!(SubLineBlock { LineBlock, Line });
 
 impl HTMLRender for e::Line {
-	fn render_html<W>(&self, stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		for c in self.children() {
-			(*c).render_html(stream)?;
+			(*c).render_html(renderer)?;
 		}
-		write!(stream, "<br>")?;
+		write!(renderer.stream, "<br>")?;
 		Ok(())
 	}
 }
@@ -341,7 +369,7 @@ impl_html_render_cat!(SubFigure { Caption, Legend, BodyElement });
 impl_html_render_simple!(Caption => caption);
 
 impl HTMLRender for e::Legend {
-	fn render_html<W>(&self, _stream: &mut W) -> Result<(), Error> where W: Write {
+	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
 		unimplemented!();
 	}
 }