src/librustdoc/html/markdown.rs

   1 // Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Markdown formatting for rustdoc
  12 //!
  13 //! This module implements markdown formatting through the pulldown-cmark
  14 //! rust-library. This module exposes all of the
  15 //! functionality through a unit-struct, `Markdown`, which has an implementation
  16 //! of `fmt::Display`. Example usage:
  17 //!
  18 //! ```
  19 //! #![feature(rustc_private)]
  20 //!
  21 //! use rustdoc::html::markdown::{RenderType, Markdown};
  22 //!
  23 //! let s = "My *markdown* _text_";
  24 //! let html = format!("{}", Markdown(s, RenderType::Pulldown));
  25 //! // ... something using html
  26 //! ```
  27
  28 #![allow(non_camel_case_types)]
  29
  30 use libc;
  31 use std::slice;
  32
  33 use std::cell::RefCell;
  34 use std::collections::{HashMap, VecDeque};
  35 use std::default::Default;
  36 use std::fmt::{self, Write};
  37 use std::str;
  38 use syntax::feature_gate::UnstableFeatures;
  39 use syntax::codemap::Span;
  40
  41 use html::render::derive_id;
  42 use html::toc::TocBuilder;
  43 use html::highlight;
  44 use html::escape::Escape;
  45 use test;
  46
  47 use pulldown_cmark::{html, Event, Tag, Parser};
  48 use pulldown_cmark::{Options, OPTION_ENABLE_FOOTNOTES, OPTION_ENABLE_TABLES};
  49
  50 #[derive(PartialEq, Debug, Clone, Copy)]
  51 pub enum RenderType {
  52     Hoedown,
  53     Pulldown,
  54 }
  55
  56 /// A unit struct which has the `fmt::Display` trait implemented. When
  57 /// formatted, this struct will emit the HTML corresponding to the rendered
  58 /// version of the contained markdown string.
  59 /// The second parameter is a list of link replacements
  60 // The third parameter is whether we need a shorter version or not.
  61 pub struct Markdown<'a>(pub &'a str, pub &'a [(String, String)], pub RenderType);
  62 /// A unit struct like `Markdown`, that renders the markdown with a
  63 /// table of contents.
  64 pub struct MarkdownWithToc<'a>(pub &'a str, pub RenderType);
  65 /// A unit struct like `Markdown`, that renders the markdown escaping HTML tags.
  66 pub struct MarkdownHtml<'a>(pub &'a str, pub RenderType);
  67 /// A unit struct like `Markdown`, that renders only the first paragraph.
  68 pub struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [(String, String)]);
  69
  70 /// Controls whether a line will be hidden or shown in HTML output.
  71 ///
  72 /// All lines are used in documentation tests.
  73 enum Line<'a> {
  74     Hidden(&'a str),
  75     Shown(&'a str),
  76 }
  77
  78 impl<'a> Line<'a> {
  79     fn for_html(self) -> Option<&'a str> {
  80         match self {
  81             Line::Shown(l) => Some(l),
  82             Line::Hidden(_) => None,
  83         }
  84     }
  85
  86     fn for_code(self) -> &'a str {
  87         match self {
  88             Line::Shown(l) |
  89             Line::Hidden(l) => l,
  90         }
  91     }
  92 }
  93
  94 // FIXME: There is a minor inconsistency here. For lines that start with ##, we
  95 // have no easy way of removing a potential single space after the hashes, which
  96 // is done in the single # case. This inconsistency seems okay, if non-ideal. In
  97 // order to fix it we'd have to iterate to find the first non-# character, and
  98 // then reallocate to remove it; which would make us return a String.
  99 fn map_line(s: &str) -> Line {
 100     let trimmed = s.trim();
 101     if trimmed.starts_with("##") {
 102         Line::Shown(&trimmed[1..])
 103     } else if trimmed.starts_with("# ") {
 104         // # text
 105         Line::Hidden(&trimmed[2..])
 106     } else if trimmed == "#" {
 107         // We cannot handle '#text' because it could be #[attr].
 108         Line::Hidden("")
 109     } else {
 110         Line::Shown(s)
 111     }
 112 }
 113
 114 /// Returns a new string with all consecutive whitespace collapsed into
 115 /// single spaces.
 116 ///
 117 /// Any leading or trailing whitespace will be trimmed.
 118 fn collapse_whitespace(s: &str) -> String {
 119     s.split_whitespace().collect::<Vec<_>>().join(" ")
 120 }
 121
 122 /// Convert chars from a title for an id.
 123 ///
 124 /// "Hello, world!" -> "hello-world"
 125 fn slugify(c: char) -> Option<char> {
 126     if c.is_alphanumeric() || c == '-' || c == '_' {
 127         if c.is_ascii() {
 128             Some(c.to_ascii_lowercase())
 129         } else {
 130             Some(c)
 131         }
 132     } else if c.is_whitespace() && c.is_ascii() {
 133         Some('-')
 134     } else {
 135         None
 136     }
 137 }
 138
 139 // Information about the playground if a URL has been specified, containing an
 140 // optional crate name and the URL.
 141 thread_local!(pub static PLAYGROUND: RefCell<Option<(Option<String>, String)>> = {
 142     RefCell::new(None)
 143 });
 144
 145 /// Adds syntax highlighting and playground Run buttons to rust code blocks.
 146 struct CodeBlocks<'a, I: Iterator<Item = Event<'a>>> {
 147     inner: I,
 148 }
 149
 150 impl<'a, I: Iterator<Item = Event<'a>>> CodeBlocks<'a, I> {
 151     fn new(iter: I) -> Self {
 152         CodeBlocks {
 153             inner: iter,
 154         }
 155     }
 156 }
 157
 158 impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'a, I> {
 159     type Item = Event<'a>;
 160
 161     fn next(&mut self) -> Option<Self::Item> {
 162         let event = self.inner.next();
 163         let compile_fail;
 164         let ignore;
 165         if let Some(Event::Start(Tag::CodeBlock(lang))) = event {
 166             let parse_result = LangString::parse(&lang);
 167             if !parse_result.rust {
 168                 return Some(Event::Start(Tag::CodeBlock(lang)));
 169             }
 170             compile_fail = parse_result.compile_fail;
 171             ignore = parse_result.ignore;
 172         } else {
 173             return event;
 174         }
 175
 176         let mut origtext = String::new();
 177         for event in &mut self.inner {
 178             match event {
 179                 Event::End(Tag::CodeBlock(..)) => break,
 180                 Event::Text(ref s) => {
 181                     origtext.push_str(s);
 182                 }
 183                 _ => {}
 184             }
 185         }
 186         let lines = origtext.lines().filter_map(|l| map_line(l).for_html());
 187         let text = lines.collect::<Vec<&str>>().join("\n");
 188         PLAYGROUND.with(|play| {
 189             // insert newline to clearly separate it from the
 190             // previous block so we can shorten the html output
 191             let mut s = String::from("\n");
 192             let playground_button = play.borrow().as_ref().and_then(|&(ref krate, ref url)| {
 193                 if url.is_empty() {
 194                     return None;
 195                 }
 196                 let test = origtext.lines()
 197                     .map(|l| map_line(l).for_code())
 198                     .collect::<Vec<&str>>().join("\n");
 199                 let krate = krate.as_ref().map(|s| &**s);
 200                 let (test, _) = test::make_test(&test, krate, false,
 201                                            &Default::default());
 202                 let channel = if test.contains("#![feature(") {
 203                     "&amp;version=nightly"
 204                 } else {
 205                     ""
 206                 };
 207                 // These characters don't need to be escaped in a URI.
 208                 // FIXME: use a library function for percent encoding.
 209                 fn dont_escape(c: u8) -> bool {
 210                     (b'a' <= c && c <= b'z') ||
 211                     (b'A' <= c && c <= b'Z') ||
 212                     (b'0' <= c && c <= b'9') ||
 213                     c == b'-' || c == b'_' || c == b'.' ||
 214                     c == b'~' || c == b'!' || c == b'\'' ||
 215                     c == b'(' || c == b')' || c == b'*'
 216                 }
 217                 let mut test_escaped = String::new();
 218                 for b in test.bytes() {
 219                     if dont_escape(b) {
 220                         test_escaped.push(char::from(b));
 221                     } else {
 222                         write!(test_escaped, "%{:02X}", b).unwrap();
 223                     }
 224                 }
 225                 Some(format!(
 226                     r#"<a class="test-arrow" target="_blank" href="{}?code={}{}">Run</a>"#,
 227                     url, test_escaped, channel
 228                 ))
 229             });
 230             let tooltip = if ignore {
 231                 Some(("This example is not tested", "ignore"))
 232             } else if compile_fail {
 233                 Some(("This example deliberately fails to compile", "compile_fail"))
 234             } else {
 235                 None
 236             };
 237             s.push_str(&highlight::render_with_highlighting(
 238                         &text,
 239                         Some(&format!("rust-example-rendered{}",
 240                                       if ignore { " ignore" }
 241                                       else if compile_fail { " compile_fail" }
 242                                       else { "" })),
 243                         None,
 244                         playground_button.as_ref().map(String::as_str),
 245                         tooltip));
 246             Some(Event::Html(s.into()))
 247         })
 248     }
 249 }
 250
 251 /// Make headings links with anchor ids and build up TOC.
 252 struct LinkReplacer<'a, 'b, I: Iterator<Item = Event<'a>>> {
 253     inner: I,
 254     links: &'b [(String, String)]
 255 }
 256
 257 impl<'a, 'b, I: Iterator<Item = Event<'a>>> LinkReplacer<'a, 'b, I> {
 258     fn new(iter: I, links: &'b [(String, String)]) -> Self {
 259         LinkReplacer {
 260             inner: iter,
 261             links
 262         }
 263     }
 264 }
 265
 266 impl<'a, 'b, I: Iterator<Item = Event<'a>>> Iterator for LinkReplacer<'a, 'b, I> {
 267     type Item = Event<'a>;
 268
 269     fn next(&mut self) -> Option<Self::Item> {
 270         let event = self.inner.next();
 271         if let Some(Event::Start(Tag::Link(dest, text))) = event {
 272             if let Some(&(_, ref replace)) = self.links.into_iter().find(|link| &*link.0 == &*dest)
 273             {
 274                 Some(Event::Start(Tag::Link(replace.to_owned().into(), text)))
 275             } else {
 276                 Some(Event::Start(Tag::Link(dest, text)))
 277             }
 278         } else {
 279             event
 280         }
 281     }
 282 }
 283
 284 /// Make headings links with anchor ids and build up TOC.
 285 struct HeadingLinks<'a, 'b, I: Iterator<Item = Event<'a>>> {
 286     inner: I,
 287     toc: Option<&'b mut TocBuilder>,
 288     buf: VecDeque<Event<'a>>,
 289 }
 290
 291 impl<'a, 'b, I: Iterator<Item = Event<'a>>> HeadingLinks<'a, 'b, I> {
 292     fn new(iter: I, toc: Option<&'b mut TocBuilder>) -> Self {
 293         HeadingLinks {
 294             inner: iter,
 295             toc,
 296             buf: VecDeque::new(),
 297         }
 298     }
 299 }
 300
 301 impl<'a, 'b, I: Iterator<Item = Event<'a>>> Iterator for HeadingLinks<'a, 'b, I> {
 302     type Item = Event<'a>;
 303
 304     fn next(&mut self) -> Option<Self::Item> {
 305         if let Some(e) = self.buf.pop_front() {
 306             return Some(e);
 307         }
 308
 309         let event = self.inner.next();
 310         if let Some(Event::Start(Tag::Header(level))) = event {
 311             let mut id = String::new();
 312             for event in &mut self.inner {
 313                 match event {
 314                     Event::End(Tag::Header(..)) => break,
 315                     Event::Text(ref text) => id.extend(text.chars().filter_map(slugify)),
 316                     _ => {},
 317                 }
 318                 self.buf.push_back(event);
 319             }
 320             let id = derive_id(id);
 321
 322             if let Some(ref mut builder) = self.toc {
 323                 let mut html_header = String::new();
 324                 html::push_html(&mut html_header, self.buf.iter().cloned());
 325                 let sec = builder.push(level as u32, html_header, id.clone());
 326                 self.buf.push_front(Event::InlineHtml(format!("{} ", sec).into()));
 327             }
 328
 329             self.buf.push_back(Event::InlineHtml(format!("</a></h{}>", level).into()));
 330
 331             let start_tags = format!("<h{level} id=\"{id}\" class=\"section-header\">\
 332                                       <a href=\"#{id}\">",
 333                                      id = id,
 334                                      level = level);
 335             return Some(Event::InlineHtml(start_tags.into()));
 336         }
 337         event
 338     }
 339 }
 340
 341 /// Extracts just the first paragraph.
 342 struct SummaryLine<'a, I: Iterator<Item = Event<'a>>> {
 343     inner: I,
 344     started: bool,
 345     depth: u32,
 346 }
 347
 348 impl<'a, I: Iterator<Item = Event<'a>>> SummaryLine<'a, I> {
 349     fn new(iter: I) -> Self {
 350         SummaryLine {
 351             inner: iter,
 352             started: false,
 353             depth: 0,
 354         }
 355     }
 356 }
 357
 358 impl<'a, I: Iterator<Item = Event<'a>>> Iterator for SummaryLine<'a, I> {
 359     type Item = Event<'a>;
 360
 361     fn next(&mut self) -> Option<Self::Item> {
 362         if self.started && self.depth == 0 {
 363             return None;
 364         }
 365         if !self.started {
 366             self.started = true;
 367         }
 368         let event = self.inner.next();
 369         match event {
 370             Some(Event::Start(..)) => self.depth += 1,
 371             Some(Event::End(..)) => self.depth -= 1,
 372             _ => {}
 373         }
 374         event
 375     }
 376 }
 377
 378 /// Moves all footnote definitions to the end and add back links to the
 379 /// references.
 380 struct Footnotes<'a, I: Iterator<Item = Event<'a>>> {
 381     inner: I,
 382     footnotes: HashMap<String, (Vec<Event<'a>>, u16)>,
 383 }
 384
 385 impl<'a, I: Iterator<Item = Event<'a>>> Footnotes<'a, I> {
 386     fn new(iter: I) -> Self {
 387         Footnotes {
 388             inner: iter,
 389             footnotes: HashMap::new(),
 390         }
 391     }
 392     fn get_entry(&mut self, key: &str) -> &mut (Vec<Event<'a>>, u16) {
 393         let new_id = self.footnotes.keys().count() + 1;
 394         let key = key.to_owned();
 395         self.footnotes.entry(key).or_insert((Vec::new(), new_id as u16))
 396     }
 397 }
 398
 399 impl<'a, I: Iterator<Item = Event<'a>>> Iterator for Footnotes<'a, I> {
 400     type Item = Event<'a>;
 401
 402     fn next(&mut self) -> Option<Self::Item> {
 403         loop {
 404             match self.inner.next() {
 405                 Some(Event::FootnoteReference(ref reference)) => {
 406                     let entry = self.get_entry(&reference);
 407                     let reference = format!("<sup id=\"fnref{0}\"><a href=\"#fn{0}\">{0}\
 408                                              </a></sup>",
 409                                             (*entry).1);
 410                     return Some(Event::Html(reference.into()));
 411                 }
 412                 Some(Event::Start(Tag::FootnoteDefinition(def))) => {
 413                     let mut content = Vec::new();
 414                     for event in &mut self.inner {
 415                         if let Event::End(Tag::FootnoteDefinition(..)) = event {
 416                             break;
 417                         }
 418                         content.push(event);
 419                     }
 420                     let entry = self.get_entry(&def);
 421                     (*entry).0 = content;
 422                 }
 423                 Some(e) => return Some(e),
 424                 None => {
 425                     if !self.footnotes.is_empty() {
 426                         let mut v: Vec<_> = self.footnotes.drain().map(|(_, x)| x).collect();
 427                         v.sort_by(|a, b| a.1.cmp(&b.1));
 428                         let mut ret = String::from("<div class=\"footnotes\"><hr><ol>");
 429                         for (mut content, id) in v {
 430                             write!(ret, "<li id=\"fn{}\">", id).unwrap();
 431                             let mut is_paragraph = false;
 432                             if let Some(&Event::End(Tag::Paragraph)) = content.last() {
 433                                 content.pop();
 434                                 is_paragraph = true;
 435                             }
 436                             html::push_html(&mut ret, content.into_iter());
 437                             write!(ret,
 438                                    "&nbsp;<a href=\"#fnref{}\" rev=\"footnote\">↩</a>",
 439                                    id).unwrap();
 440                             if is_paragraph {
 441                                 ret.push_str("</p>");
 442                             }
 443                             ret.push_str("</li>");
 444                         }
 445                         ret.push_str("</ol></div>");
 446                         return Some(Event::Html(ret.into()));
 447                     } else {
 448                         return None;
 449                     }
 450                 }
 451             }
 452         }
 453     }
 454 }
 455
 456 const DEF_OUNIT: libc::size_t = 64;
 457 const HOEDOWN_EXT_NO_INTRA_EMPHASIS: libc::c_uint = 1 << 11;
 458 const HOEDOWN_EXT_TABLES: libc::c_uint = 1 << 0;
 459 const HOEDOWN_EXT_FENCED_CODE: libc::c_uint = 1 << 1;
 460 const HOEDOWN_EXT_AUTOLINK: libc::c_uint = 1 << 3;
 461 const HOEDOWN_EXT_STRIKETHROUGH: libc::c_uint = 1 << 4;
 462 const HOEDOWN_EXT_SUPERSCRIPT: libc::c_uint = 1 << 8;
 463 const HOEDOWN_EXT_FOOTNOTES: libc::c_uint = 1 << 2;
 464 const HOEDOWN_HTML_ESCAPE: libc::c_uint = 1 << 1;
 465
 466 const HOEDOWN_EXTENSIONS: libc::c_uint =
 467     HOEDOWN_EXT_NO_INTRA_EMPHASIS | HOEDOWN_EXT_TABLES |
 468     HOEDOWN_EXT_FENCED_CODE | HOEDOWN_EXT_AUTOLINK |
 469     HOEDOWN_EXT_STRIKETHROUGH | HOEDOWN_EXT_SUPERSCRIPT |
 470     HOEDOWN_EXT_FOOTNOTES;
 471
 472 enum hoedown_document {}
 473
 474 type blockcodefn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 475                                  *const hoedown_buffer, *const hoedown_renderer_data,
 476                                  libc::size_t);
 477
 478 type blockquotefn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 479                                   *const hoedown_renderer_data, libc::size_t);
 480
 481 type headerfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 482                               libc::c_int, *const hoedown_renderer_data,
 483                               libc::size_t);
 484
 485 type blockhtmlfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 486                                  *const hoedown_renderer_data, libc::size_t);
 487
 488 type codespanfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 489                                 *const hoedown_renderer_data, libc::size_t) -> libc::c_int;
 490
 491 type linkfn = extern "C" fn (*mut hoedown_buffer, *const hoedown_buffer,
 492                              *const hoedown_buffer, *const hoedown_buffer,
 493                              *const hoedown_renderer_data, libc::size_t) -> libc::c_int;
 494
 495 type entityfn = extern "C" fn (*mut hoedown_buffer, *const hoedown_buffer,
 496                                *const hoedown_renderer_data, libc::size_t);
 497
 498 type normaltextfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 499                                   *const hoedown_renderer_data, libc::size_t);
 500
 501 #[repr(C)]
 502 struct hoedown_renderer_data {
 503     opaque: *mut libc::c_void,
 504 }
 505
 506 #[repr(C)]
 507 struct hoedown_renderer {
 508     opaque: *mut libc::c_void,
 509
 510     blockcode: Option<blockcodefn>,
 511     blockquote: Option<blockquotefn>,
 512     header: Option<headerfn>,
 513
 514     other_block_level_callbacks: [libc::size_t; 11],
 515
 516     blockhtml: Option<blockhtmlfn>,
 517
 518     /* span level callbacks - NULL or return 0 prints the span verbatim */
 519     autolink: libc::size_t, // unused
 520     codespan: Option<codespanfn>,
 521     other_span_level_callbacks_1: [libc::size_t; 7],
 522     link: Option<linkfn>,
 523     other_span_level_callbacks_2: [libc::size_t; 6],
 524
 525     /* low level callbacks - NULL copies input directly into the output */
 526     entity: Option<entityfn>,
 527     normal_text: Option<normaltextfn>,
 528
 529     /* header and footer */
 530     other_callbacks: [libc::size_t; 2],
 531 }
 532
 533 #[repr(C)]
 534 struct hoedown_html_renderer_state {
 535     opaque: *mut libc::c_void,
 536     toc_data: html_toc_data,
 537     flags: libc::c_uint,
 538     link_attributes: Option<extern "C" fn(*mut hoedown_buffer,
 539                                           *const hoedown_buffer,
 540                                           *const hoedown_renderer_data)>,
 541 }
 542
 543 #[repr(C)]
 544 struct html_toc_data {
 545     header_count: libc::c_int,
 546     current_level: libc::c_int,
 547     level_offset: libc::c_int,
 548     nesting_level: libc::c_int,
 549 }
 550
 551 #[repr(C)]
 552 struct hoedown_buffer {
 553     data: *const u8,
 554     size: libc::size_t,
 555     asize: libc::size_t,
 556     unit: libc::size_t,
 557 }
 558
 559 struct MyOpaque {
 560     dfltblk: extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 561                            *const hoedown_buffer, *const hoedown_renderer_data,
 562                            libc::size_t),
 563     toc_builder: Option<TocBuilder>,
 564     links_out: Option<Vec<String>>,
 565     links_replace: Vec<(String, String)>,
 566 }
 567
 568 extern {
 569     fn hoedown_html_renderer_new(render_flags: libc::c_uint,
 570                                  nesting_level: libc::c_int)
 571         -> *mut hoedown_renderer;
 572     fn hoedown_html_renderer_free(renderer: *mut hoedown_renderer);
 573
 574     fn hoedown_document_new(rndr: *const hoedown_renderer,
 575                             extensions: libc::c_uint,
 576                             max_nesting: libc::size_t) -> *mut hoedown_document;
 577     fn hoedown_document_render(doc: *mut hoedown_document,
 578                                ob: *mut hoedown_buffer,
 579                                document: *const u8,
 580                                doc_size: libc::size_t);
 581     fn hoedown_document_free(md: *mut hoedown_document);
 582
 583     fn hoedown_buffer_new(unit: libc::size_t) -> *mut hoedown_buffer;
 584     fn hoedown_buffer_free(b: *mut hoedown_buffer);
 585     fn hoedown_buffer_put(b: *mut hoedown_buffer, c: *const u8, len: libc::size_t);
 586 }
 587
 588 impl hoedown_buffer {
 589     fn as_bytes(&self) -> &[u8] {
 590         unsafe { slice::from_raw_parts(self.data, self.size as usize) }
 591     }
 592 }
 593
 594 extern fn hoedown_block(ob: *mut hoedown_buffer, orig_text: *const hoedown_buffer,
 595                         lang: *const hoedown_buffer, data: *const hoedown_renderer_data,
 596                         line: libc::size_t) {
 597     unsafe {
 598         if orig_text.is_null() { return }
 599
 600         let opaque = (*data).opaque as *mut hoedown_html_renderer_state;
 601         let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque);
 602         let text = (*orig_text).as_bytes();
 603         let origtext = str::from_utf8(text).unwrap();
 604         let origtext = origtext.trim_left();
 605         debug!("docblock: ==============\n{:?}\n=======", text);
 606         let mut compile_fail = false;
 607         let mut ignore = false;
 608
 609         let rendered = if lang.is_null() || origtext.is_empty() {
 610             false
 611         } else {
 612             let rlang = (*lang).as_bytes();
 613             let rlang = str::from_utf8(rlang).unwrap();
 614             let parse_result = LangString::parse(rlang);
 615             compile_fail = parse_result.compile_fail;
 616             ignore = parse_result.ignore;
 617             if !parse_result.rust {
 618                 (my_opaque.dfltblk)(ob, orig_text, lang,
 619                                     opaque as *const hoedown_renderer_data,
 620                                     line);
 621                 true
 622             } else {
 623                 false
 624             }
 625         };
 626
 627         let lines = origtext.lines().filter_map(|l| map_line(l).for_html());
 628         let text = lines.collect::<Vec<&str>>().join("\n");
 629         if rendered { return }
 630         PLAYGROUND.with(|play| {
 631             // insert newline to clearly separate it from the
 632             // previous block so we can shorten the html output
 633             let mut s = String::from("\n");
 634             let playground_button = play.borrow().as_ref().and_then(|&(ref krate, ref url)| {
 635                 if url.is_empty() {
 636                     return None;
 637                 }
 638                 let test = origtext.lines()
 639                     .map(|l| map_line(l).for_code())
 640                     .collect::<Vec<&str>>().join("\n");
 641                 let krate = krate.as_ref().map(|s| &**s);
 642                 let (test, _) = test::make_test(&test, krate, false,
 643                                                 &Default::default());
 644                 let channel = if test.contains("#![feature(") {
 645                     "&amp;version=nightly"
 646                 } else {
 647                     ""
 648                 };
 649                 // These characters don't need to be escaped in a URI.
 650                 // FIXME: use a library function for percent encoding.
 651                 fn dont_escape(c: u8) -> bool {
 652                     (b'a' <= c && c <= b'z') ||
 653                     (b'A' <= c && c <= b'Z') ||
 654                     (b'0' <= c && c <= b'9') ||
 655                     c == b'-' || c == b'_' || c == b'.' ||
 656                     c == b'~' || c == b'!' || c == b'\'' ||
 657                     c == b'(' || c == b')' || c == b'*'
 658                 }
 659                 let mut test_escaped = String::new();
 660                 for b in test.bytes() {
 661                     if dont_escape(b) {
 662                         test_escaped.push(char::from(b));
 663                     } else {
 664                         write!(test_escaped, "%{:02X}", b).unwrap();
 665                     }
 666                 }
 667                 Some(format!(
 668                     r#"<a class="test-arrow" target="_blank" href="{}?code={}{}">Run</a>"#,
 669                     url, test_escaped, channel
 670                 ))
 671             });
 672             let tooltip = if ignore {
 673                 Some(("This example is not tested", "ignore"))
 674             } else if compile_fail {
 675                 Some(("This example deliberately fails to compile", "compile_fail"))
 676             } else {
 677                 None
 678             };
 679             s.push_str(&highlight::render_with_highlighting(
 680                            &text,
 681                            Some(&format!("rust-example-rendered{}",
 682                                          if ignore { " ignore" }
 683                                          else if compile_fail { " compile_fail" }
 684                                          else { "" })),
 685                            None,
 686                            playground_button.as_ref().map(String::as_str),
 687                            tooltip));
 688             hoedown_buffer_put(ob, s.as_ptr(), s.len());
 689         })
 690     }
 691 }
 692
 693 extern fn hoedown_header(ob: *mut hoedown_buffer, text: *const hoedown_buffer,
 694                          level: libc::c_int, data: *const hoedown_renderer_data,
 695                          _: libc::size_t) {
 696     // hoedown does this, we may as well too
 697     unsafe { hoedown_buffer_put(ob, "\n".as_ptr(), 1); }
 698
 699     // Extract the text provided
 700     let s = if text.is_null() {
 701         "".to_owned()
 702     } else {
 703         let s = unsafe { (*text).as_bytes() };
 704         str::from_utf8(&s).unwrap().to_owned()
 705     };
 706
 707     // Discard '<em>', '<code>' tags and some escaped characters,
 708     // transform the contents of the header into a hyphenated string
 709     // without non-alphanumeric characters other than '-' and '_'.
 710     //
 711     // This is a terrible hack working around how hoedown gives us rendered
 712     // html for text rather than the raw text.
 713     let mut id = s.clone();
 714     let repl_sub = vec!["<em>", "</em>", "<code>", "</code>",
 715                         "<strong>", "</strong>",
 716                         "&lt;", "&gt;", "&amp;", "&#39;", "&quot;"];
 717     for sub in repl_sub {
 718         id = id.replace(sub, "");
 719     }
 720     let id = id.chars().filter_map(|c| {
 721         if c.is_alphanumeric() || c == '-' || c == '_' {
 722             if c.is_ascii() {
 723                 Some(c.to_ascii_lowercase())
 724             } else {
 725                 Some(c)
 726             }
 727         } else if c.is_whitespace() && c.is_ascii() {
 728             Some('-')
 729         } else {
 730             None
 731         }
 732     }).collect::<String>();
 733
 734     let opaque = unsafe { (*data).opaque as *mut hoedown_html_renderer_state };
 735     let opaque = unsafe { &mut *((*opaque).opaque as *mut MyOpaque) };
 736
 737     let id = derive_id(id);
 738
 739     let sec = opaque.toc_builder.as_mut().map_or("".to_owned(), |builder| {
 740         format!("{} ", builder.push(level as u32, s.clone(), id.clone()))
 741     });
 742
 743     // Render the HTML
 744     let text = format!("<h{lvl} id='{id}' class='section-header'>\
 745                        <a href='#{id}'>{sec}{}</a></h{lvl}>",
 746                        s, lvl = level, id = id, sec = sec);
 747
 748     unsafe { hoedown_buffer_put(ob, text.as_ptr(), text.len()); }
 749 }
 750
 751 extern fn hoedown_codespan(
 752     ob: *mut hoedown_buffer,
 753     text: *const hoedown_buffer,
 754     _: *const hoedown_renderer_data,
 755     _: libc::size_t
 756 ) -> libc::c_int {
 757     let content = if text.is_null() {
 758         "".to_owned()
 759     } else {
 760         let bytes = unsafe { (*text).as_bytes() };
 761         let s = str::from_utf8(bytes).unwrap();
 762         collapse_whitespace(s)
 763     };
 764
 765     let content = format!("<code>{}</code>", Escape(&content));
 766     unsafe {
 767         hoedown_buffer_put(ob, content.as_ptr(), content.len());
 768     }
 769     // Return anything except 0, which would mean "also print the code span verbatim".
 770     1
 771 }
 772
 773 pub fn render(w: &mut fmt::Formatter,
 774               s: &str,
 775               links: &[(String, String)],
 776               print_toc: bool,
 777               html_flags: libc::c_uint) -> fmt::Result {
 778     extern fn hoedown_link(
 779         ob: *mut hoedown_buffer,
 780         content: *const hoedown_buffer,
 781         link: *const hoedown_buffer,
 782         title: *const hoedown_buffer,
 783         data: *const hoedown_renderer_data,
 784         _line: libc::size_t
 785     ) -> libc::c_int {
 786         if link.is_null() {
 787             return 0;
 788         }
 789
 790         let opaque = unsafe { (*data).opaque as *mut hoedown_html_renderer_state };
 791         let opaque = unsafe { &mut *((*opaque).opaque as *mut MyOpaque) };
 792
 793         let link = {
 794             let s = unsafe { (*link).as_bytes() };
 795             str::from_utf8(s).unwrap().to_owned()
 796         };
 797
 798         let link = if let Some(&(_, ref new_target)) = opaque.links_replace
 799                                                              .iter()
 800                                                              .find(|t| &*t.0 == &*link) {
 801             new_target.to_owned()
 802         } else {
 803             return 0;
 804         };
 805
 806         let content = unsafe {
 807             content.as_ref().map(|c| {
 808                 let s = c.as_bytes();
 809                 str::from_utf8(s).unwrap().to_owned()
 810             })
 811         };
 812
 813         let title = unsafe {
 814             title.as_ref().map(|t| {
 815                 let s = t.as_bytes();
 816                 str::from_utf8(s).unwrap().to_owned()
 817             })
 818         };
 819
 820         let link_out = format!("<a href=\"{link}\"{title}>{content}</a>",
 821                                link = link,
 822                                title = title.map_or(String::new(),
 823                                                     |t| format!(" title=\"{}\"", t)),
 824                                content = content.unwrap_or(String::new()));
 825
 826         unsafe { hoedown_buffer_put(ob, link_out.as_ptr(), link_out.len()); }
 827
 828         //return "anything but 0" to show we've written the link in
 829         1
 830     }
 831
 832     unsafe {
 833         let ob = hoedown_buffer_new(DEF_OUNIT);
 834         let renderer = hoedown_html_renderer_new(html_flags, 0);
 835         let mut opaque = MyOpaque {
 836             dfltblk: (*renderer).blockcode.unwrap(),
 837             toc_builder: if print_toc {Some(TocBuilder::new())} else {None},
 838             links_out: None,
 839             links_replace: links.to_vec(),
 840         };
 841         (*((*renderer).opaque as *mut hoedown_html_renderer_state)).opaque
 842                 = &mut opaque as *mut _ as *mut libc::c_void;
 843         (*renderer).blockcode = Some(hoedown_block);
 844         (*renderer).header = Some(hoedown_header);
 845         (*renderer).codespan = Some(hoedown_codespan);
 846         (*renderer).link = Some(hoedown_link);
 847
 848         let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
 849         hoedown_document_render(document, ob, s.as_ptr(),
 850                                 s.len() as libc::size_t);
 851         hoedown_document_free(document);
 852
 853         hoedown_html_renderer_free(renderer);
 854
 855         let mut ret = opaque.toc_builder.map_or(Ok(()), |builder| {
 856             write!(w, "<nav id=\"TOC\">{}</nav>", builder.into_toc())
 857         });
 858
 859         if ret.is_ok() {
 860             let buf = (*ob).as_bytes();
 861             ret = w.write_str(str::from_utf8(buf).unwrap());
 862         }
 863         hoedown_buffer_free(ob);
 864         ret
 865     }
 866 }
 867
 868 pub fn old_find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Span) {
 869     extern fn block(_ob: *mut hoedown_buffer,
 870                     text: *const hoedown_buffer,
 871                     lang: *const hoedown_buffer,
 872                     data: *const hoedown_renderer_data,
 873                     line: libc::size_t) {
 874         unsafe {
 875             if text.is_null() { return }
 876             let block_info = if lang.is_null() {
 877                 LangString::all_false()
 878             } else {
 879                 let lang = (*lang).as_bytes();
 880                 let s = str::from_utf8(lang).unwrap();
 881                 LangString::parse(s)
 882             };
 883             if !block_info.rust { return }
 884             let text = (*text).as_bytes();
 885             let opaque = (*data).opaque as *mut hoedown_html_renderer_state;
 886             let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
 887             let text = str::from_utf8(text).unwrap();
 888             let lines = text.lines().map(|l| map_line(l).for_code());
 889             let text = lines.collect::<Vec<&str>>().join("\n");
 890             let filename = tests.get_filename();
 891
 892             if tests.render_type == RenderType::Hoedown {
 893                 let line = tests.get_line() + line;
 894                 tests.add_test(text.to_owned(),
 895                                block_info.should_panic, block_info.no_run,
 896                                block_info.ignore, block_info.test_harness,
 897                                block_info.compile_fail, block_info.error_codes,
 898                                line, filename, block_info.allow_fail);
 899             } else {
 900                 tests.add_old_test(text, filename);
 901             }
 902         }
 903     }
 904
 905     extern fn header(_ob: *mut hoedown_buffer,
 906                      text: *const hoedown_buffer,
 907                      level: libc::c_int, data: *const hoedown_renderer_data,
 908                      _: libc::size_t) {
 909         unsafe {
 910             let opaque = (*data).opaque as *mut hoedown_html_renderer_state;
 911             let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
 912             if text.is_null() {
 913                 tests.register_header("", level as u32);
 914             } else {
 915                 let text = (*text).as_bytes();
 916                 let text = str::from_utf8(text).unwrap();
 917                 tests.register_header(text, level as u32);
 918             }
 919         }
 920     }
 921
 922     tests.set_position(position);
 923     unsafe {
 924         let ob = hoedown_buffer_new(DEF_OUNIT);
 925         let renderer = hoedown_html_renderer_new(0, 0);
 926         (*renderer).blockcode = Some(block);
 927         (*renderer).header = Some(header);
 928         (*((*renderer).opaque as *mut hoedown_html_renderer_state)).opaque
 929                 = tests as *mut _ as *mut libc::c_void;
 930
 931         let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
 932         hoedown_document_render(document, ob, doc.as_ptr(),
 933                                 doc.len() as libc::size_t);
 934         hoedown_document_free(document);
 935
 936         hoedown_html_renderer_free(renderer);
 937         hoedown_buffer_free(ob);
 938     }
 939 }
 940
 941 pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Span) {
 942     tests.set_position(position);
 943
 944     let mut parser = Parser::new(doc);
 945     let mut prev_offset = 0;
 946     let mut nb_lines = 0;
 947     let mut register_header = None;
 948     'main: while let Some(event) = parser.next() {
 949         match event {
 950             Event::Start(Tag::CodeBlock(s)) => {
 951                 let block_info = if s.is_empty() {
 952                     LangString::all_false()
 953                 } else {
 954                     LangString::parse(&*s)
 955                 };
 956                 if !block_info.rust {
 957                     continue
 958                 }
 959                 let mut test_s = String::new();
 960                 let mut offset = None;
 961                 loop {
 962                     let event = parser.next();
 963                     if let Some(event) = event {
 964                         match event {
 965                             Event::End(Tag::CodeBlock(_)) => break,
 966                             Event::Text(ref s) => {
 967                                 test_s.push_str(s);
 968                                 if offset.is_none() {
 969                                     offset = Some(parser.get_offset());
 970                                 }
 971                             }
 972                             _ => {}
 973                         }
 974                     } else {
 975                         break 'main;
 976                     }
 977                 }
 978                 let offset = offset.unwrap_or(0);
 979                 let lines = test_s.lines().map(|l| map_line(l).for_code());
 980                 let text = lines.collect::<Vec<&str>>().join("\n");
 981                 nb_lines += doc[prev_offset..offset].lines().count();
 982                 let line = tests.get_line() + (nb_lines - 1);
 983                 let filename = tests.get_filename();
 984                 tests.add_test(text.to_owned(),
 985                                block_info.should_panic, block_info.no_run,
 986                                block_info.ignore, block_info.test_harness,
 987                                block_info.compile_fail, block_info.error_codes,
 988                                line, filename, block_info.allow_fail);
 989                 prev_offset = offset;
 990             }
 991             Event::Start(Tag::Header(level)) => {
 992                 register_header = Some(level as u32);
 993             }
 994             Event::Text(ref s) if register_header.is_some() => {
 995                 let level = register_header.unwrap();
 996                 if s.is_empty() {
 997                     tests.register_header("", level);
 998                 } else {
 999                     tests.register_header(s, level);
1000                 }
1001                 register_header = None;
1002             }
1003             _ => {}
1004         }
1005     }
1006 }
1007
1008 #[derive(Eq, PartialEq, Clone, Debug)]
1009 struct LangString {
1010     original: String,
1011     should_panic: bool,
1012     no_run: bool,
1013     ignore: bool,
1014     rust: bool,
1015     test_harness: bool,
1016     compile_fail: bool,
1017     error_codes: Vec<String>,
1018     allow_fail: bool,
1019 }
1020
1021 impl LangString {
1022     fn all_false() -> LangString {
1023         LangString {
1024             original: String::new(),
1025             should_panic: false,
1026             no_run: false,
1027             ignore: false,
1028             rust: true,  // NB This used to be `notrust = false`
1029             test_harness: false,
1030             compile_fail: false,
1031             error_codes: Vec::new(),
1032             allow_fail: false,
1033         }
1034     }
1035
1036     fn parse(string: &str) -> LangString {
1037         let mut seen_rust_tags = false;
1038         let mut seen_other_tags = false;
1039         let mut data = LangString::all_false();
1040         let mut allow_error_code_check = false;
1041         if UnstableFeatures::from_environment().is_nightly_build() {
1042             allow_error_code_check = true;
1043         }
1044
1045         data.original = string.to_owned();
1046         let tokens = string.split(|c: char|
1047             !(c == '_' || c == '-' || c.is_alphanumeric())
1048         );
1049
1050         for token in tokens {
1051             match token.trim() {
1052                 "" => {},
1053                 "should_panic" => {
1054                     data.should_panic = true;
1055                     seen_rust_tags = seen_other_tags == false;
1056                 }
1057                 "no_run" => { data.no_run = true; seen_rust_tags = !seen_other_tags; }
1058                 "ignore" => { data.ignore = true; seen_rust_tags = !seen_other_tags; }
1059                 "allow_fail" => { data.allow_fail = true; seen_rust_tags = !seen_other_tags; }
1060                 "rust" => { data.rust = true; seen_rust_tags = true; }
1061                 "test_harness" => {
1062                     data.test_harness = true;
1063                     seen_rust_tags = !seen_other_tags || seen_rust_tags;
1064                 }
1065                 "compile_fail" => {
1066                     data.compile_fail = true;
1067                     seen_rust_tags = !seen_other_tags || seen_rust_tags;
1068                     data.no_run = true;
1069                 }
1070                 x if allow_error_code_check && x.starts_with("E") && x.len() == 5 => {
1071                     if let Ok(_) = x[1..].parse::<u32>() {
1072                         data.error_codes.push(x.to_owned());
1073                         seen_rust_tags = !seen_other_tags || seen_rust_tags;
1074                     } else {
1075                         seen_other_tags = true;
1076                     }
1077                 }
1078                 _ => { seen_other_tags = true }
1079             }
1080         }
1081
1082         data.rust &= !seen_other_tags || seen_rust_tags;
1083
1084         data
1085     }
1086 }
1087
1088 impl<'a> fmt::Display for Markdown<'a> {
1089     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1090         let Markdown(md, links, render_type) = *self;
1091
1092         // This is actually common enough to special-case
1093         if md.is_empty() { return Ok(()) }
1094         if render_type == RenderType::Hoedown {
1095             render(fmt, md, links, false, 0)
1096         } else {
1097             let mut opts = Options::empty();
1098             opts.insert(OPTION_ENABLE_TABLES);
1099             opts.insert(OPTION_ENABLE_FOOTNOTES);
1100
1101             let p = Parser::new_ext(md, opts);
1102
1103             let mut s = String::with_capacity(md.len() * 3 / 2);
1104
1105             html::push_html(&mut s,
1106                             Footnotes::new(
1107                                 CodeBlocks::new(
1108                                     LinkReplacer::new(
1109                                         HeadingLinks::new(p, None),
1110                                         links))));
1111
1112             fmt.write_str(&s)
1113         }
1114     }
1115 }
1116
1117 impl<'a> fmt::Display for MarkdownWithToc<'a> {
1118     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1119         let MarkdownWithToc(md, render_type) = *self;
1120
1121         if render_type == RenderType::Hoedown {
1122             render(fmt, md, &[], true, 0)
1123         } else {
1124             let mut opts = Options::empty();
1125             opts.insert(OPTION_ENABLE_TABLES);
1126             opts.insert(OPTION_ENABLE_FOOTNOTES);
1127
1128             let p = Parser::new_ext(md, opts);
1129
1130             let mut s = String::with_capacity(md.len() * 3 / 2);
1131
1132             let mut toc = TocBuilder::new();
1133
1134             html::push_html(&mut s,
1135                             Footnotes::new(CodeBlocks::new(HeadingLinks::new(p, Some(&mut toc)))));
1136
1137             write!(fmt, "<nav id=\"TOC\">{}</nav>", toc.into_toc())?;
1138
1139             fmt.write_str(&s)
1140         }
1141     }
1142 }
1143
1144 impl<'a> fmt::Display for MarkdownHtml<'a> {
1145     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1146         let MarkdownHtml(md, render_type) = *self;
1147
1148         // This is actually common enough to special-case
1149         if md.is_empty() { return Ok(()) }
1150         if render_type == RenderType::Hoedown {
1151             render(fmt, md, &[], false, HOEDOWN_HTML_ESCAPE)
1152         } else {
1153             let mut opts = Options::empty();
1154             opts.insert(OPTION_ENABLE_TABLES);
1155             opts.insert(OPTION_ENABLE_FOOTNOTES);
1156
1157             let p = Parser::new_ext(md, opts);
1158
1159             // Treat inline HTML as plain text.
1160             let p = p.map(|event| match event {
1161                 Event::Html(text) | Event::InlineHtml(text) => Event::Text(text),
1162                 _ => event
1163             });
1164
1165             let mut s = String::with_capacity(md.len() * 3 / 2);
1166
1167             html::push_html(&mut s,
1168                             Footnotes::new(CodeBlocks::new(HeadingLinks::new(p, None))));
1169
1170             fmt.write_str(&s)
1171         }
1172     }
1173 }
1174
1175 impl<'a> fmt::Display for MarkdownSummaryLine<'a> {
1176     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1177         let MarkdownSummaryLine(md, links) = *self;
1178         // This is actually common enough to special-case
1179         if md.is_empty() { return Ok(()) }
1180
1181         let p = Parser::new(md);
1182
1183         let mut s = String::new();
1184
1185         html::push_html(&mut s, LinkReplacer::new(SummaryLine::new(p), links));
1186
1187         fmt.write_str(&s)
1188     }
1189 }
1190
1191 pub fn plain_summary_line(md: &str) -> String {
1192     struct ParserWrapper<'a> {
1193         inner: Parser<'a>,
1194         is_in: isize,
1195         is_first: bool,
1196     }
1197
1198     impl<'a> Iterator for ParserWrapper<'a> {
1199         type Item = String;
1200
1201         fn next(&mut self) -> Option<String> {
1202             let next_event = self.inner.next();
1203             if next_event.is_none() {
1204                 return None
1205             }
1206             let next_event = next_event.unwrap();
1207             let (ret, is_in) = match next_event {
1208                 Event::Start(Tag::Paragraph) => (None, 1),
1209                 Event::Start(Tag::Code) => (Some("`".to_owned()), 1),
1210                 Event::End(Tag::Code) => (Some("`".to_owned()), -1),
1211                 Event::Start(Tag::Header(_)) => (None, 1),
1212                 Event::Text(ref s) if self.is_in > 0 => (Some(s.as_ref().to_owned()), 0),
1213                 Event::End(Tag::Paragraph) | Event::End(Tag::Header(_)) => (None, -1),
1214                 _ => (None, 0),
1215             };
1216             if is_in > 0 || (is_in < 0 && self.is_in > 0) {
1217                 self.is_in += is_in;
1218             }
1219             if ret.is_some() {
1220                 self.is_first = false;
1221                 ret
1222             } else {
1223                 Some(String::new())
1224             }
1225         }
1226     }
1227     let mut s = String::with_capacity(md.len() * 3 / 2);
1228     let mut p = ParserWrapper {
1229         inner: Parser::new(md),
1230         is_in: 0,
1231         is_first: true,
1232     };
1233     while let Some(t) = p.next() {
1234         if !t.is_empty() {
1235             s.push_str(&t);
1236         }
1237     }
1238     s
1239 }
1240
1241 pub fn markdown_links(md: &str, render_type: RenderType) -> Vec<String> {
1242     if md.is_empty() {
1243         return vec![];
1244     }
1245
1246     match render_type {
1247         RenderType::Hoedown => {
1248             extern fn hoedown_link(
1249                 _ob: *mut hoedown_buffer,
1250                 _content: *const hoedown_buffer,
1251                 link: *const hoedown_buffer,
1252                 _title: *const hoedown_buffer,
1253                 data: *const hoedown_renderer_data,
1254                 _line: libc::size_t
1255             ) -> libc::c_int {
1256                 if link.is_null() {
1257                     return 0;
1258                 }
1259
1260                 let opaque = unsafe { (*data).opaque as *mut hoedown_html_renderer_state };
1261                 let opaque = unsafe { &mut *((*opaque).opaque as *mut MyOpaque) };
1262
1263                 if let Some(ref mut links) = opaque.links_out {
1264                     let s = unsafe { (*link).as_bytes() };
1265                     let s = str::from_utf8(&s).unwrap().to_owned();
1266
1267                     debug!("found link: {}", s);
1268
1269                     links.push(s);
1270                 }
1271
1272                 //returning 0 here means "emit the span verbatim", but we're not using the output
1273                 //anyway so we don't really care
1274                 0
1275             }
1276
1277             unsafe {
1278                 let ob = hoedown_buffer_new(DEF_OUNIT);
1279                 let renderer = hoedown_html_renderer_new(0, 0);
1280                 let mut opaque = MyOpaque {
1281                     dfltblk: (*renderer).blockcode.unwrap(),
1282                     toc_builder: None,
1283                     links_out: Some(vec![]),
1284                     links_replace: vec![],
1285                 };
1286                 (*((*renderer).opaque as *mut hoedown_html_renderer_state)).opaque
1287                         = &mut opaque as *mut _ as *mut libc::c_void;
1288                 (*renderer).blockcode = Some(hoedown_block);
1289                 (*renderer).header = Some(hoedown_header);
1290                 (*renderer).codespan = Some(hoedown_codespan);
1291                 (*renderer).link = Some(hoedown_link);
1292
1293                 let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
1294                 hoedown_document_render(document, ob, md.as_ptr(),
1295                                         md.len() as libc::size_t);
1296                 hoedown_document_free(document);
1297
1298                 hoedown_html_renderer_free(renderer);
1299                 hoedown_buffer_free(ob);
1300
1301                 opaque.links_out.unwrap()
1302             }
1303         }
1304         RenderType::Pulldown => {
1305             let mut opts = Options::empty();
1306             opts.insert(OPTION_ENABLE_TABLES);
1307             opts.insert(OPTION_ENABLE_FOOTNOTES);
1308
1309             let p = Parser::new_ext(md, opts);
1310
1311             let iter = Footnotes::new(CodeBlocks::new(HeadingLinks::new(p, None)));
1312             let mut links = vec![];
1313
1314             for ev in iter {
1315                 if let Event::Start(Tag::Link(dest, _)) = ev {
1316                     debug!("found link: {}", dest);
1317                     links.push(dest.into_owned());
1318                 }
1319             }
1320
1321             links
1322         }
1323     }
1324 }
1325
1326 #[cfg(test)]
1327 mod tests {
1328     use super::{LangString, Markdown, MarkdownHtml};
1329     use super::plain_summary_line;
1330     use super::RenderType;
1331     use html::render::reset_ids;
1332
1333     #[test]
1334     fn test_lang_string_parse() {
1335         fn t(s: &str,
1336             should_panic: bool, no_run: bool, ignore: bool, rust: bool, test_harness: bool,
1337             compile_fail: bool, allow_fail: bool, error_codes: Vec<String>) {
1338             assert_eq!(LangString::parse(s), LangString {
1339                 should_panic,
1340                 no_run,
1341                 ignore,
1342                 rust,
1343                 test_harness,
1344                 compile_fail,
1345                 error_codes,
1346                 original: s.to_owned(),
1347                 allow_fail,
1348             })
1349         }
1350
1351         fn v() -> Vec<String> {
1352             Vec::new()
1353         }
1354
1355         // marker                | should_panic| no_run| ignore| rust | test_harness| compile_fail
1356         //                       | allow_fail | error_codes
1357         t("",                      false,        false,  false,  true,  false, false, false, v());
1358         t("rust",                  false,        false,  false,  true,  false, false, false, v());
1359         t("sh",                    false,        false,  false,  false, false, false, false, v());
1360         t("ignore",                false,        false,  true,   true,  false, false, false, v());
1361         t("should_panic",          true,         false,  false,  true,  false, false, false, v());
1362         t("no_run",                false,        true,   false,  true,  false, false, false, v());
1363         t("test_harness",          false,        false,  false,  true,  true,  false, false, v());
1364         t("compile_fail",          false,        true,   false,  true,  false, true,  false, v());
1365         t("allow_fail",            false,        false,  false,  true,  false, false, true,  v());
1366         t("{.no_run .example}",    false,        true,   false,  true,  false, false, false, v());
1367         t("{.sh .should_panic}",   true,         false,  false,  false, false, false, false, v());
1368         t("{.example .rust}",      false,        false,  false,  true,  false, false, false, v());
1369         t("{.test_harness .rust}", false,        false,  false,  true,  true,  false, false, v());
1370         t("text, no_run",          false,        true,   false,  false, false, false, false, v());
1371         t("text,no_run",           false,        true,   false,  false, false, false, false, v());
1372     }
1373
1374     #[test]
1375     fn issue_17736() {
1376         let markdown = "# title";
1377         format!("{}", Markdown(markdown, RenderType::Pulldown));
1378         reset_ids(true);
1379     }
1380
1381     #[test]
1382     fn test_header() {
1383         fn t(input: &str, expect: &str) {
1384             let output = format!("{}", Markdown(input, RenderType::Pulldown));
1385             assert_eq!(output, expect, "original: {}", input);
1386             reset_ids(true);
1387         }
1388
1389         t("# Foo bar", "<h1 id=\"foo-bar\" class=\"section-header\">\
1390           <a href=\"#foo-bar\">Foo bar</a></h1>");
1391         t("## Foo-bar_baz qux", "<h2 id=\"foo-bar_baz-qux\" class=\"section-\
1392           header\"><a href=\"#foo-bar_baz-qux\">Foo-bar_baz qux</a></h2>");
1393         t("### **Foo** *bar* baz!?!& -_qux_-%",
1394           "<h3 id=\"foo-bar-baz--qux-\" class=\"section-header\">\
1395           <a href=\"#foo-bar-baz--qux-\"><strong>Foo</strong> \
1396           <em>bar</em> baz!?!&amp; -<em>qux</em>-%</a></h3>");
1397         t("#### **Foo?** & \\*bar?!*  _`baz`_ ❤ #qux",
1398           "<h4 id=\"foo--bar--baz--qux\" class=\"section-header\">\
1399           <a href=\"#foo--bar--baz--qux\"><strong>Foo?</strong> &amp; *bar?!*  \
1400           <em><code>baz</code></em> ❤ #qux</a></h4>");
1401     }
1402
1403     #[test]
1404     fn test_header_ids_multiple_blocks() {
1405         fn t(input: &str, expect: &str) {
1406             let output = format!("{}", Markdown(input, RenderType::Pulldown));
1407             assert_eq!(output, expect, "original: {}", input);
1408         }
1409
1410         let test = || {
1411             t("# Example", "<h1 id=\"example\" class=\"section-header\">\
1412               <a href=\"#example\">Example</a></h1>");
1413             t("# Panics", "<h1 id=\"panics\" class=\"section-header\">\
1414               <a href=\"#panics\">Panics</a></h1>");
1415             t("# Example", "<h1 id=\"example-1\" class=\"section-header\">\
1416               <a href=\"#example-1\">Example</a></h1>");
1417             t("# Main", "<h1 id=\"main-1\" class=\"section-header\">\
1418               <a href=\"#main-1\">Main</a></h1>");
1419             t("# Example", "<h1 id=\"example-2\" class=\"section-header\">\
1420               <a href=\"#example-2\">Example</a></h1>");
1421             t("# Panics", "<h1 id=\"panics-1\" class=\"section-header\">\
1422               <a href=\"#panics-1\">Panics</a></h1>");
1423         };
1424         test();
1425         reset_ids(true);
1426         test();
1427     }
1428
1429     #[test]
1430     fn test_plain_summary_line() {
1431         fn t(input: &str, expect: &str) {
1432             let output = plain_summary_line(input);
1433             assert_eq!(output, expect, "original: {}", input);
1434         }
1435
1436         t("hello [Rust](https://www.rust-lang.org) :)", "hello Rust :)");
1437         t("hello [Rust](https://www.rust-lang.org \"Rust\") :)", "hello Rust :)");
1438         t("code `let x = i32;` ...", "code `let x = i32;` ...");
1439         t("type `Type<'static>` ...", "type `Type<'static>` ...");
1440         t("# top header", "top header");
1441         t("## header", "header");
1442     }
1443
1444     #[test]
1445     fn test_markdown_html_escape() {
1446         fn t(input: &str, expect: &str) {
1447             let output = format!("{}", MarkdownHtml(input, RenderType::Pulldown));
1448             assert_eq!(output, expect, "original: {}", input);
1449         }
1450
1451         t("`Struct<'a, T>`", "<p><code>Struct&lt;'a, T&gt;</code></p>\n");
1452         t("Struct<'a, T>", "<p>Struct&lt;'a, T&gt;</p>\n");
1453         t("Struct<br>", "<p>Struct&lt;br&gt;</p>\n");
1454     }
1455 }