---

yaml
---
r: 102438
b: refs/heads/master
c: f22c96c
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 69b8ef806b3742ba7d41a77cd216713c84f36254
+refs/heads/master: f22c96cc888eac4c1c5d44ea4765e5c2a65f64f3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/src/librustdoc/html/markdown.rs

@@ -36,12 +36,16 @@ use std::str;
 use std::vec;
 use collections::HashMap;
 
+use html::toc::TocBuilder;
 use html::highlight;
 
 /// A unit struct which has the `fmt::Show` trait implemented. When
 /// formatted, this struct will emit the HTML corresponding to the rendered
 /// version of the contained markdown string.
 pub struct Markdown<'a>(&'a str);
+/// A unit struct like `Markdown`, that renders the markdown with a
+/// table of contents.
+pub struct MarkdownWithToc<'a>(&'a str);
 
 static OUTPUT_UNIT: libc::size_t = 64;
 static MKDEXT_NO_INTRA_EMPHASIS: libc::c_uint = 1 << 0;
@@ -75,6 +79,7 @@ struct html_renderopt {
 struct my_opaque {
     opt: html_renderopt,
     dfltblk: extern "C" fn(*buf, *buf, *buf, *libc::c_void),
+    toc_builder: Option<TocBuilder>,
 }
 
 struct buf {
@@ -121,7 +126,7 @@ fn stripped_filtered_line<'a>(s: &'a str) -> Option<&'a str> {
 
 local_data_key!(used_header_map: HashMap<~str, uint>)
 
-pub fn render(w: &mut io::Writer, s: &str) -> fmt::Result {
+pub fn render(w: &mut io::Writer, s: &str, print_toc: bool) -> fmt::Result {
     extern fn block(ob: *buf, text: *buf, lang: *buf, opaque: *libc::c_void) {
         unsafe {
             let my_opaque: &my_opaque = cast::transmute(opaque);
@@ -162,7 +167,7 @@ pub fn render(w: &mut io::Writer, s: &str) -> fmt::Result {
     }
 
     extern fn header(ob: *buf, text: *buf, level: libc::c_int,
-                     _opaque: *libc::c_void) {
+                     opaque: *libc::c_void) {
         // sundown does this, we may as well too
         "\n".with_c_str(|p| unsafe { bufputs(ob, p) });
 
@@ -183,6 +188,8 @@ pub fn render(w: &mut io::Writer, s: &str) -> fmt::Result {
             }
         }).to_owned_vec().connect("-");
 
+        let opaque = unsafe {&mut *(opaque as *mut my_opaque)};
+
         // Make sure our hyphenated ID is unique for this page
         let id = local_data::get_mut(used_header_map, |map| {
             let map = map.unwrap();
@@ -194,9 +201,18 @@ pub fn render(w: &mut io::Writer, s: &str) -> fmt::Result {
             id.clone()
         });
 
+        let sec = match opaque.toc_builder {
+            Some(ref mut builder) => {
+                builder.push(level as u32, s.clone(), id.clone())
+            }
+            None => {""}
+        };
+
         // Render the HTML
-        let text = format!(r#"<h{lvl} id="{id}">{}</h{lvl}>"#,
-                           s, lvl = level, id = id);
+        let text = format!(r#"<h{lvl} id="{id}">{sec_len,plural,=0{}other{{sec} }}{}</h{lvl}>"#,
+                           s, lvl = level, id = id,
+                           sec_len = sec.len(), sec = sec);
+
         text.with_c_str(|p| unsafe { bufputs(ob, p) });
     }
 
@@ -218,23 +234,30 @@ pub fn render(w: &mut io::Writer, s: &str) -> fmt::Result {
         let mut callbacks: sd_callbacks = mem::init();
 
         sdhtml_renderer(&callbacks, &options, 0);
-        let opaque = my_opaque {
+        let mut opaque = my_opaque {
             opt: options,
             dfltblk: callbacks.blockcode.unwrap(),
+            toc_builder: if print_toc {Some(TocBuilder::new())} else {None}
         };
         callbacks.blockcode = Some(block);
         callbacks.header = Some(header);
         let markdown = sd_markdown_new(extensions, 16, &callbacks,
-                                       &opaque as *my_opaque as *libc::c_void);
+                                       &mut opaque as *mut my_opaque as *libc::c_void);
 
 
         sd_markdown_render(ob, s.as_ptr(), s.len() as libc::size_t, markdown);
         sd_markdown_free(markdown);
 
-        let ret = vec::raw::buf_as_slice((*ob).data, (*ob).size as uint, |buf| {
-            w.write(buf)
-        });
+        let mut ret = match opaque.toc_builder {
+            Some(b) => write!(w, "<nav id=\"TOC\">{}</nav>", b.into_toc()),
+            None => Ok(())
+        };
 
+        if ret.is_ok() {
+            ret = vec::raw::buf_as_slice((*ob).data, (*ob).size as uint, |buf| {
+                w.write(buf)
+            });
+        }
         bufrelease(ob);
         ret
     }
@@ -319,6 +342,13 @@ impl<'a> fmt::Show for Markdown<'a> {
         let Markdown(md) = *self;
         // This is actually common enough to special-case
         if md.len() == 0 { return Ok(()) }
-        render(fmt.buf, md.as_slice())
+        render(fmt.buf, md.as_slice(), false)
+    }
+}
+
+impl<'a> fmt::Show for MarkdownWithToc<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let MarkdownWithToc(md) = *self;
+        render(fmt.buf, md.as_slice(), true)
     }
 }