Format (#38)

3 files changed, 566 insertions, 343 deletions

diff --git a/renderer/src/html.rs b/renderer/src/html.rs
index 4244349..feef29d 100644
--- a/renderer/src/html.rs
+++ b/renderer/src/html.rs
@@ -7,406 +7,601 @@ use failure::Error;
 
 // use crate::url::Url;
 use document_tree::{
-	Document,Element,HasChildren,ExtraAttributes,
-	elements as e,
-	extra_attributes as a,
-	element_categories as c,
-	attribute_types as at,
+    attribute_types as at, element_categories as c, elements as e, extra_attributes as a, Document,
+    Element, ExtraAttributes, HasChildren,
 };
 
-
 // static FOOTNOTE_SYMBOLS: [char; 10] = ['*', '†', '‡', '§', '¶', '#', '♠', '♥', '♦', '♣'];
 
-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(&mut renderer)
-	} else {
-		for c in document.children() {
-			(*c).render_html(&mut renderer)?;
-			writeln!(renderer.stream)?;
-		}
-		Ok(())
-	}
+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(&mut renderer)
+    } else {
+        for c in document.children() {
+            (*c).render_html(&mut renderer)?;
+            writeln!(renderer.stream)?;
+        }
+        Ok(())
+    }
 }
 
 fn escape_html(text: &str) -> String {
-	text.replace('&', "&amp;")
-		.replace('<', "&lt;")
-		.replace('>', "&gt;")
-		.replace('"', "&quot;")
+    text.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
 }
 
-struct HTMLRenderer<W> where W: Write {
-	stream: W,
-	level: u8,
+struct HTMLRenderer<W>
+where
+    W: Write,
+{
+    stream: W,
+    level: u8,
 }
 
 trait HTMLRender {
-	fn render_html<W>(&self, renderer: &mut HTMLRenderer<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, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-			match self {$(
-				c::$cat::$member(elem) => (**elem).render_html(renderer),
-			)+}
-		}
-	}
+    impl HTMLRender for c::$cat {
+        fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+            match self {$(
+                c::$cat::$member(elem) => (**elem).render_html(renderer),
+            )+}
+        }
+    }
 }}
 
 macro_rules! impl_html_render_simple {
-	(
-		$type1:ident => $tag1:ident $( [$($post1:tt)+] )?,
-		$( $type:ident => $tag:ident $( [$($post:tt)+] )? ),+
-	) => {
-		impl_html_render_simple!($type1 => $tag1 $([$($post1)+])?);
-		$( impl_html_render_simple!($type => $tag $([$($post)+])?); )+
-	};
-	( $type:ident => $tag:ident ) => {
-		impl_html_render_simple!($type => $tag[""]);
-	};
-	( $type:ident => $tag:ident [ $post:expr ] ) => {
-		impl HTMLRender for e::$type {
-			fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-				let multiple_children = self.children().len() > 1;
-				write!(renderer.stream, "<{}", stringify!($tag))?;
-				if self.classes().len() > 0 {
-					write!(renderer.stream, " class=\"{}\"", self.classes().join(" "))?;
-				}
-				write!(renderer.stream, ">")?;
-				if multiple_children { write!(renderer.stream, $post)?; }
-				for c in self.children() {
-					(*c).render_html(renderer)?;
-					if multiple_children { write!(renderer.stream, $post)?; }
-				}
-				write!(renderer.stream, "</{}>", stringify!($tag))?;
-				Ok(())
-			}
-		}
-	};
+    (
+        $type1:ident => $tag1:ident $( [$($post1:tt)+] )?,
+        $( $type:ident => $tag:ident $( [$($post:tt)+] )? ),+
+    ) => {
+        impl_html_render_simple!($type1 => $tag1 $([$($post1)+])?);
+        $( impl_html_render_simple!($type => $tag $([$($post)+])?); )+
+    };
+    ( $type:ident => $tag:ident ) => {
+        impl_html_render_simple!($type => $tag[""]);
+    };
+    ( $type:ident => $tag:ident [ $post:expr ] ) => {
+        impl HTMLRender for e::$type {
+            fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+                let multiple_children = self.children().len() > 1;
+                write!(renderer.stream, "<{}", stringify!($tag))?;
+                if self.classes().len() > 0 {
+                    write!(renderer.stream, " class=\"{}\"", self.classes().join(" "))?;
+                }
+                write!(renderer.stream, ">")?;
+                if multiple_children { write!(renderer.stream, $post)?; }
+                for c in self.children() {
+                    (*c).render_html(renderer)?;
+                    if multiple_children { write!(renderer.stream, $post)?; }
+                }
+                write!(renderer.stream, "</{}>", stringify!($tag))?;
+                Ok(())
+            }
+        }
+    };
 }
 
 macro_rules! impl_html_render_simple_nochildren {( $($type:ident => $tag:ident),+ ) => { $(
-	impl HTMLRender for e::$type {
-		fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-			write!(renderer.stream, "<{0}></{0}>", stringify!($tag))?;
-			Ok(())
-		}
-	}
+    impl HTMLRender for e::$type {
+        fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
+            write!(renderer.stream, "<{0}></{0}>", stringify!($tag))?;
+            Ok(())
+        }
+    }
 )+ }}
 
 // Impl
 
 impl HTMLRender for Document {
-	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(renderer)?;
-			writeln!(renderer.stream)?;
-		}
-		writeln!(renderer.stream, "</html>")?;
-		Ok(())
-	}
-}
-
-impl_html_render_cat!(StructuralSubElement { Title, Subtitle, Decoration, Docinfo, SubStructure });
+    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(renderer)?;
+            writeln!(renderer.stream)?;
+        }
+        writeln!(renderer.stream, "</html>")?;
+        Ok(())
+    }
+}
+
+impl_html_render_cat!(StructuralSubElement {
+    Title,
+    Subtitle,
+    Decoration,
+    Docinfo,
+    SubStructure
+});
 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(())
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// Like “YAML frontmatter” in Markdown
-		unimplemented!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// Header or footer
-		unimplemented!();
-	}
-}
-
-impl_html_render_cat!(SubStructure { Topic, Sidebar, Transition, Section, BodyElement });
+    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);
 
 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>")?;
-		renderer.level -= 1;
-		Ok(())
-	}
+    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>")?;
+        renderer.level -= 1;
+        Ok(())
+    }
 }
 
 impl HTMLRender for e::Transition {
-	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		write!(renderer.stream, "<hr/>")?;
-		Ok(())
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// A mini section with title
-		unimplemented!();
-	}
-}
-
-impl_html_render_cat!(BodyElement { Paragraph, LiteralBlock, DoctestBlock, MathBlock, Rubric, SubstitutionDefinition, Comment, Pending, Target, Raw, Image, Compound, Container, BulletList, EnumeratedList, DefinitionList, FieldList, OptionList, LineBlock, BlockQuote, Admonition, Attention, Hint, Note, Caution, Danger, Error, Important, Tip, Warning, Footnote, Citation, SystemMessage, Figure, Table });
+    fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        // A mini section with title
+        unimplemented!();
+    }
+}
+
+impl_html_render_cat!(BodyElement {
+    Paragraph,
+    LiteralBlock,
+    DoctestBlock,
+    MathBlock,
+    Rubric,
+    SubstitutionDefinition,
+    Comment,
+    Pending,
+    Target,
+    Raw,
+    Image,
+    Compound,
+    Container,
+    BulletList,
+    EnumeratedList,
+    DefinitionList,
+    FieldList,
+    OptionList,
+    LineBlock,
+    BlockQuote,
+    Admonition,
+    Attention,
+    Hint,
+    Note,
+    Caution,
+    Danger,
+    Error,
+    Important,
+    Tip,
+    Warning,
+    Footnote,
+    Citation,
+    SystemMessage,
+    Figure,
+    Table
+});
 impl_html_render_simple!(Paragraph => p, MathBlock => math, Rubric => a, Compound => p, Container => div, BulletList => ul["\n"], EnumeratedList => ol["\n"], DefinitionList => dl["\n"], FieldList => dl["\n"], OptionList => pre, LineBlock => div["\n"], BlockQuote => blockquote, Admonition => aside, Attention => aside, Hint => aside, Note => aside, Caution => aside, Danger => aside, Error => aside, Important => aside, Tip => aside, Warning => aside, Figure => figure);
-impl_html_render_simple_nochildren!(Table => table);  //TODO: after implementing the table, move it to elems with children
+impl_html_render_simple_nochildren!(Table => table); //TODO: after implementing the table, move it to elems with children
 
 // circumvent E0119
-trait IMark {} impl IMark for e::Image {} impl IMark for e::ImageInline {}
-impl<I> HTMLRender for I where I: e::Element + a::ExtraAttributes<a::Image> + IMark {
-	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!(renderer.stream, "<a href=\"{}\">", escape_html(target.as_str()))?;
-		}
-		write!(renderer.stream, "<img")?;
-		if let Some(ref alt) = extra.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!(renderer.stream, " src=\"{}\" />", escape_html(extra.uri.as_str()))?;
-		if extra.target.is_some() {
-			write!(renderer.stream, "</a>")?;
-		}
-		Ok(())
-	}
+trait IMark {}
+impl IMark for e::Image {}
+impl IMark for e::ImageInline {}
+impl<I> HTMLRender for I
+where
+    I: e::Element + a::ExtraAttributes<a::Image> + IMark,
+{
+    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!(
+                renderer.stream,
+                "<a href=\"{}\">",
+                escape_html(target.as_str())
+            )?;
+        }
+        write!(renderer.stream, "<img")?;
+        if let Some(ref alt) = extra.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!(
+            renderer.stream,
+            " src=\"{}\" />",
+            escape_html(extra.uri.as_str())
+        )?;
+        if extra.target.is_some() {
+            write!(renderer.stream, "</a>")?;
+        }
+        Ok(())
+    }
 }
 
 impl HTMLRender for e::LiteralBlock {
-	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		let mut cls_iter = self.classes().iter();
-		let is_code = cls_iter.next() == Some(&"code".to_owned());
-		write!(renderer.stream, "<pre>")?;
-		if is_code {  // TODO: support those classes not being at the start
-			if let Some(lang) = cls_iter.next() {
-				write!(renderer.stream, "<code class=\"language-{}\">", lang)?;
-			} else {
-				write!(renderer.stream, "<code>")?;
-			}
-		}
-		for c in self.children() {
-			(*c).render_html(renderer)?;
-		}
-		if is_code { write!(renderer.stream, "</code>")?; }
-		write!(renderer.stream, "</pre>")?;
-		Ok(())
-	}
+    fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        let mut cls_iter = self.classes().iter();
+        let is_code = cls_iter.next() == Some(&"code".to_owned());
+        write!(renderer.stream, "<pre>")?;
+        if is_code {
+            // TODO: support those classes not being at the start
+            if let Some(lang) = cls_iter.next() {
+                write!(renderer.stream, "<code class=\"language-{}\">", lang)?;
+            } else {
+                write!(renderer.stream, "<code>")?;
+            }
+        }
+        for c in self.children() {
+            (*c).render_html(renderer)?;
+        }
+        if is_code {
+            write!(renderer.stream, "</code>")?;
+        }
+        write!(renderer.stream, "</pre>")?;
+        Ok(())
+    }
 }
 
 impl HTMLRender for e::DoctestBlock {
-	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// TODO
-		unimplemented!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// TODO: Should those be removed after resolving them
-		Ok(())
-	}
+    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, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		write!(renderer.stream, "<!--")?;
-		for c in self.children() {
-			(*c).render_html(renderer)?;
-		}
-		write!(renderer.stream, "-->")?;
-		Ok(())
-	}
+    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(renderer)?;
+        }
+        write!(renderer.stream, "-->")?;
+        Ok(())
+    }
 }
 
 impl HTMLRender for e::Pending {
-	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!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// Should be resolved by now
-		Ok(())
-	}
+    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, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		let extra = self.extra();
-		if extra.format.contains(&at::NameToken("html".to_owned())) {
-			for c in self.children() {
-				write!(renderer.stream, "{}", c)?;
-			}
-		}
-		Ok(())
-	}
+    fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        let extra = self.extra();
+        if extra.format.contains(&at::NameToken("html".to_owned())) {
+            for c in self.children() {
+                write!(renderer.stream, "{}", c)?;
+            }
+        }
+        Ok(())
+    }
 }
 
 impl HTMLRender for e::Footnote {
-	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		unimplemented!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		unimplemented!();
-	}
+    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, 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(renderer)?;
-		}
-		write!(renderer.stream, "</figure>")?;
-		Ok(())
-	}
-}
-
-impl_html_render_cat!(TextOrInlineElement { String, Emphasis, Strong, Literal, Reference, FootnoteReference, CitationReference, SubstitutionReference, TitleReference, Abbreviation, Acronym, Superscript, Subscript, Inline, Problematic, Generated, Math, TargetInline, RawInline, ImageInline });
+    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(renderer)?;
+        }
+        write!(renderer.stream, "</figure>")?;
+        Ok(())
+    }
+}
+
+impl_html_render_cat!(TextOrInlineElement {
+    String,
+    Emphasis,
+    Strong,
+    Literal,
+    Reference,
+    FootnoteReference,
+    CitationReference,
+    SubstitutionReference,
+    TitleReference,
+    Abbreviation,
+    Acronym,
+    Superscript,
+    Subscript,
+    Inline,
+    Problematic,
+    Generated,
+    Math,
+    TargetInline,
+    RawInline,
+    ImageInline
+});
 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, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		write!(renderer.stream, "{}", escape_html(self))?;
-		Ok(())
-	}
+    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, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		let extra = self.extra();
-		write!(renderer.stream, "<a")?;
-		if let Some(ref target) = extra.refuri {
-			write!(renderer.stream, " href=\"{}\"", escape_html(target.as_str()))?;
-		}
-		/*
-		if let Some(ref name) = extra.name {
-			write!(renderer.stream, " title=\"{}\"", escape_html(&name.0))?;
-		}
-		*/
-		write!(renderer.stream, ">")?;
-		for c in self.children() {
-			(*c).render_html(renderer)?;
-		}
-		write!(renderer.stream, "</a>")?;
-		Ok(())
-	}
+    fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        let extra = self.extra();
+        write!(renderer.stream, "<a")?;
+        if let Some(ref target) = extra.refuri {
+            write!(
+                renderer.stream,
+                " href=\"{}\"",
+                escape_html(target.as_str())
+            )?;
+        }
+        /*
+        if let Some(ref name) = extra.name {
+            write!(renderer.stream, " title=\"{}\"", escape_html(&name.0))?;
+        }
+        */
+        write!(renderer.stream, ">")?;
+        for c in self.children() {
+            (*c).render_html(renderer)?;
+        }
+        write!(renderer.stream, "</a>")?;
+        Ok(())
+    }
 }
 
 impl HTMLRender for e::SubstitutionReference {
-	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!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// Broken inline markup leads to insertion of this in docutils
-		unimplemented!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// Section numbers and so on
-		unimplemented!();
-	}
+    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, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		for c in self.children() {
-			write!(renderer.stream, "{}", c)?;
-		}
-		Ok(())
-	}
+    fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        for c in self.children() {
+            write!(renderer.stream, "{}", c)?;
+        }
+        Ok(())
+    }
 }
 
-
 //--------------\\
 //Content Models\\
 //--------------\\
 
 impl_html_render_cat!(SubTopic { Title, BodyElement });
-impl_html_render_cat!(SubSidebar { Topic, Title, Subtitle, BodyElement });
+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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// Term→dt, Definition→dd, Classifier→???
-		unimplemented!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// FieldName→dt, FieldBody→dd
-		unimplemented!();
-	}
+    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, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		// OptionGroup→dt(s), Description→dd
-		unimplemented!();
-	}
+    fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        // OptionGroup→dt(s), Description→dd
+        unimplemented!();
+    }
 }
 
 impl_html_render_cat!(SubLineBlock { LineBlock, Line });
 
 impl HTMLRender for e::Line {
-	fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		for c in self.children() {
-			(*c).render_html(renderer)?;
-		}
-		write!(renderer.stream, "<br>")?;
-		Ok(())
-	}
-}
-
-impl_html_render_cat!(SubBlockQuote { Attribution, BodyElement });
+    fn render_html<W>(&self, renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        for c in self.children() {
+            (*c).render_html(renderer)?;
+        }
+        write!(renderer.stream, "<br>")?;
+        Ok(())
+    }
+}
+
+impl_html_render_cat!(SubBlockQuote {
+    Attribution,
+    BodyElement
+});
 impl_html_render_simple!(Attribution => cite); //TODO: correct?
 
-impl_html_render_cat!(SubFigure { Caption, Legend, BodyElement });
+impl_html_render_cat!(SubFigure {
+    Caption,
+    Legend,
+    BodyElement
+});
 impl_html_render_simple!(Caption => caption);
 
 impl HTMLRender for e::Legend {
-	fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error> where W: Write {
-		unimplemented!();
-	}
+    fn render_html<W>(&self, _renderer: &mut HTMLRenderer<W>) -> Result<(), Error>
+    where
+        W: Write,
+    {
+        unimplemented!();
+    }
 }
 
 //------------\\
diff --git a/renderer/src/html/tests.rs b/renderer/src/html/tests.rs
index c29e9d8..4734d65 100644
--- a/renderer/src/html/tests.rs
+++ b/renderer/src/html/tests.rs
@@ -5,43 +5,40 @@ use rst_parser::parse;
 use crate::html::render_html;
 
 fn check_renders_to(rst: &str, expected: &str) {
-	println!("Rendering:\n{}\n---", rst);
-	let doc = parse(rst).expect("Cannot parse");
-	let mut result_data: Vec<u8> = vec![];
-	render_html(&doc, &mut result_data, false).expect("Render error");
-	let result = String::from_utf8(result_data).expect("Could not decode");
-	assert_eq!(result.as_str().trim(), expected);
-	println!("{}", expected);
+    println!("Rendering:\n{}\n---", rst);
+    let doc = parse(rst).expect("Cannot parse");
+    let mut result_data: Vec<u8> = vec![];
+    render_html(&doc, &mut result_data, false).expect("Render error");
+    let result = String::from_utf8(result_data).expect("Could not decode");
+    assert_eq!(result.as_str().trim(), expected);
+    println!("{}", expected);
 }
 
 #[test]
 fn simple_string() {
-	check_renders_to(
-		"Simple String",
-		"<p>Simple String</p>",
-	);
+    check_renders_to("Simple String", "<p>Simple String</p>");
 }
 
 #[test]
 fn simple_string_with_markup() {
-	check_renders_to(
-		"Simple String with *emph* and **strong**",
-		"<p>Simple String with <em>emph</em> and <strong>strong</strong></p>",
-	);
+    check_renders_to(
+        "Simple String with *emph* and **strong**",
+        "<p>Simple String with <em>emph</em> and <strong>strong</strong></p>",
+    );
 }
 
 #[test]
 fn inline_literal() {
-	check_renders_to(
-		"Simple String with an even simpler ``inline literal``",
-		"<p>Simple String with an even simpler <code>inline literal</code></p>",
-	);
+    check_renders_to(
+        "Simple String with an even simpler ``inline literal``",
+        "<p>Simple String with an even simpler <code>inline literal</code></p>",
+    );
 }
 
 /*
 #[test]
 fn test_reference_anonymous() {
-	check_renders_to("\
+    check_renders_to("\
 A simple `anonymous reference`__
 
 __ http://www.test.com/test_url
@@ -53,28 +50,31 @@ __ http://www.test.com/test_url
 
 #[test]
 fn two_paragraphs() {
-	check_renders_to(
-		"One paragraph.\n\nTwo paragraphs.",
-		"<p>One paragraph.</p>\n<p>Two paragraphs.</p>",
-	);
+    check_renders_to(
+        "One paragraph.\n\nTwo paragraphs.",
+        "<p>One paragraph.</p>\n<p>Two paragraphs.</p>",
+    );
 }
 
 #[test]
 fn named_reference() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 A simple `named reference`_ with stuff in between the
 reference and the target.
 
 .. _`named reference`: http://www.test.com/test_url
-", "\
+",
+        "\
 <p>A simple <a href=\"http://www.test.com/test_url\">named reference</a> with stuff in between the \
 reference and the target.</p>\
-");
+",
+    );
 }
 
 #[test]
 fn standalone_hyperlinks() {
-	check_renders_to("\
+    check_renders_to("\
 Some http://url and a not_url_scheme:foo that is not supposed to be an url.
 ", "\
 <p>Some <a href=\"http://url/\">http://url</a> and a not_url_scheme:foo that is not supposed to be an url.</p>\
@@ -83,16 +83,20 @@ Some http://url and a not_url_scheme:foo that is not supposed to be an url.
 
 #[test]
 fn substitution() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 A |subst|.
 
 .. |subst| replace:: text substitution
-", "<p>A text substitution.</p>");
+",
+        "<p>A text substitution.</p>",
+    );
 }
 
 #[test]
 fn not_substitution_literal() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 hello ``foo.map(|world| world + 42)``
 
 .. |world| replace:: something different
@@ -104,15 +108,17 @@ hello ``foo.map(|world| world + 42)``
 ::
 
     hay! |x|
-", "<p>hello <code>foo.map(|world| world + 42)</code></p>
+",
+        "<p>hello <code>foo.map(|world| world + 42)</code></p>
 <pre><code>foo.map(|world| world + 42)\n</code></pre>
-<pre>hay! |x|\n</pre>");
+<pre>hay! |x|\n</pre>",
+    );
 }
 
 /*
 #[test]
 fn test_section_hierarchy() {
-	check_renders_to("\
+    check_renders_to("\
 +++++
 Title
 +++++
@@ -146,7 +152,7 @@ And even more stuff
 
 #[test]
 fn test_docinfo_title() {
-	check_renders_to("\
+    check_renders_to("\
 +++++
 Title
 +++++
@@ -169,7 +175,8 @@ Some stuff
 
 #[test]
 fn section_hierarchy() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 +++++
 Title
 +++++
@@ -188,7 +195,8 @@ Another Section
 ...............
 
 And even more stuff
-", "\
+",
+        "\
 <section id=\"title\">
 <h1>Title</h1>
 <section id=\"not-a-subtitle\">
@@ -204,12 +212,14 @@ And even more stuff
 </section>
 </section>
 </section>\
-");
+",
+    );
 }
 
 #[test]
 fn many_sections() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 +++++++++
 heading 1
 +++++++++
@@ -233,7 +243,8 @@ heading 3a
 ----------
 
 Second detail
-", "\
+",
+        "\
 <section id=\"heading-1\">
 <h1>heading 1</h1>
 <section id=\"heading-2\">
@@ -253,26 +264,30 @@ Second detail
 </section>
 </section>
 </section>\
-");
+",
+    );
 }
 
 #[test]
 fn bullet_list() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 * bullet
 * list
-", "\
+",
+        "\
 <ul>
 <li><p>bullet</p></li>
 <li><p>list</p></li>
 </ul>\
-");
+",
+    );
 }
 
 /*
 #[test]
 fn test_table() {
-	check_renders_to("\
+    check_renders_to("\
 .. table::
    :align: right
 
@@ -302,25 +317,29 @@ fn test_table() {
 
 #[test]
 fn code() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 .. code:: python
 
    def foo():
        print('Hi!')
 
        # comment
-", "\
+",
+        "\
 <pre><code class=\"language-python\">def foo():
     print('Hi!')
 
     # comment
 </code></pre>\
-");
+",
+    );
 }
 
 #[test]
 fn raw_html() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 .. raw:: html
 
    hello <span>world</span>
@@ -333,19 +352,22 @@ after
 .. raw:: something_else
 
    into a black hole this goes
-", "\
+",
+        "\
 hello <span>world</span>
 <p>paragraph
 
 paragraph</p>
 
 <p>after</p>\
-");
+",
+    );
 }
 
 #[test]
 fn comments() {
-	check_renders_to("\
+    check_renders_to(
+        "\
 .. Run-in
    comment
 
@@ -354,7 +376,8 @@ fn comments() {
     block-like
 
     with blank lines
-", "\
+",
+        "\
 <!--Run-in
 comment
 -->
@@ -362,13 +385,14 @@ comment
 
 with blank lines
 -->\
-");
+",
+    );
 }
 
 /*
 #[test]
 fn test_field_list() {
-	check_renders_to("\
+    check_renders_to("\
 Not a docinfo.
 
 :This: .. _target:
@@ -398,7 +422,7 @@ Not a docinfo.
 /*
 #[test]
 fn test_field_list_long() {
-	check_renders_to("\
+    check_renders_to("\
 Not a docinfo.
 
 :This is: a
diff --git a/renderer/src/lib.rs b/renderer/src/lib.rs
index 4d6bfdb..6e349be 100644
--- a/renderer/src/lib.rs
+++ b/renderer/src/lib.rs
@@ -1,21 +1,25 @@
 mod html;
 
-
 use std::io::Write;
 
 use failure::Error;
 
 use document_tree::Document;
 
-
-pub fn render_json<W>(document: &Document, stream: W) -> Result<(), Error> where W: Write {
-	serde_json::to_writer(stream, &document)?;
-	Ok(())
+pub fn render_json<W>(document: &Document, stream: W) -> Result<(), Error>
+where
+    W: Write,
+{
+    serde_json::to_writer(stream, &document)?;
+    Ok(())
 }
 
-pub fn render_xml<W>(document: &Document, stream: W) -> Result<(), Error> where W: Write {
-	serde_xml_rs::to_writer(stream, &document).map_err(failure::SyncFailure::new)?;
-	Ok(())
+pub fn render_xml<W>(document: &Document, stream: W) -> Result<(), Error>
+where
+    W: Write,
+{
+    serde_xml_rs::to_writer(stream, &document).map_err(failure::SyncFailure::new)?;
+    Ok(())
 }
 
 pub use html::render_html;