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 hoedown C-library
  14 //! (bundled into the rust runtime). This module self-contains the C bindings
  15 //! and necessary legwork to render markdown, and exposes all of the
  16 //! functionality through a unit-struct, `Markdown`, which has an implementation
  17 //! of `fmt::String`. Example usage:
  18 //!
  19 //! ```rust,ignore
  20 //! use rustdoc::html::markdown::Markdown;
  21 //!
  22 //! let s = "My *markdown* _text_";
  23 //! let html = format!("{}", Markdown(s));
  24 //! // ... something using html
  25 //! ```
  26
  27 #![allow(dead_code)]
  28 #![allow(non_camel_case_types)]
  29
  30 use libc;
  31 use std::ascii::AsciiExt;
  32 use std::ffi::CString;
  33 use std::cell::{RefCell, Cell};
  34 use std::collections::HashMap;
  35 use std::fmt;
  36 use std::slice;
  37 use std::str;
  38
  39 use html::toc::TocBuilder;
  40 use html::highlight;
  41 use html::escape::Escape;
  42 use test;
  43
  44 /// A unit struct which has the `fmt::String` trait implemented. When
  45 /// formatted, this struct will emit the HTML corresponding to the rendered
  46 /// version of the contained markdown string.
  47 pub struct Markdown<'a>(pub &'a str);
  48 /// A unit struct like `Markdown`, that renders the markdown with a
  49 /// table of contents.
  50 pub struct MarkdownWithToc<'a>(pub &'a str);
  51
  52 const DEF_OUNIT: libc::size_t = 64;
  53 const HOEDOWN_EXT_NO_INTRA_EMPHASIS: libc::c_uint = 1 << 10;
  54 const HOEDOWN_EXT_TABLES: libc::c_uint = 1 << 0;
  55 const HOEDOWN_EXT_FENCED_CODE: libc::c_uint = 1 << 1;
  56 const HOEDOWN_EXT_AUTOLINK: libc::c_uint = 1 << 3;
  57 const HOEDOWN_EXT_STRIKETHROUGH: libc::c_uint = 1 << 4;
  58 const HOEDOWN_EXT_SUPERSCRIPT: libc::c_uint = 1 << 8;
  59 const HOEDOWN_EXT_FOOTNOTES: libc::c_uint = 1 << 2;
  60
  61 const HOEDOWN_EXTENSIONS: libc::c_uint =
  62     HOEDOWN_EXT_NO_INTRA_EMPHASIS | HOEDOWN_EXT_TABLES |
  63     HOEDOWN_EXT_FENCED_CODE | HOEDOWN_EXT_AUTOLINK |
  64     HOEDOWN_EXT_STRIKETHROUGH | HOEDOWN_EXT_SUPERSCRIPT |
  65     HOEDOWN_EXT_FOOTNOTES;
  66
  67 type hoedown_document = libc::c_void;  // this is opaque to us
  68
  69 type blockcodefn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
  70                                  *const hoedown_buffer, *mut libc::c_void);
  71
  72 type headerfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
  73                               libc::c_int, *mut libc::c_void);
  74
  75 #[repr(C)]
  76 struct hoedown_renderer {
  77     opaque: *mut hoedown_html_renderer_state,
  78     blockcode: Option<blockcodefn>,
  79     blockquote: Option<extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
  80                                      *mut libc::c_void)>,
  81     blockhtml: Option<extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
  82                                     *mut libc::c_void)>,
  83     header: Option<headerfn>,
  84     other: [libc::size_t; 28],
  85 }
  86
  87 #[repr(C)]
  88 struct hoedown_html_renderer_state {
  89     opaque: *mut libc::c_void,
  90     toc_data: html_toc_data,
  91     flags: libc::c_uint,
  92     link_attributes: Option<extern "C" fn(*mut hoedown_buffer,
  93                                           *const hoedown_buffer,
  94                                           *mut libc::c_void)>,
  95 }
  96
  97 #[repr(C)]
  98 struct html_toc_data {
  99     header_count: libc::c_int,
 100     current_level: libc::c_int,
 101     level_offset: libc::c_int,
 102     nesting_level: libc::c_int,
 103 }
 104
 105 struct MyOpaque {
 106     dfltblk: extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
 107                            *const hoedown_buffer, *mut libc::c_void),
 108     toc_builder: Option<TocBuilder>,
 109 }
 110
 111 #[repr(C)]
 112 struct hoedown_buffer {
 113     data: *const u8,
 114     size: libc::size_t,
 115     asize: libc::size_t,
 116     unit: libc::size_t,
 117 }
 118
 119 // hoedown FFI
 120 #[link(name = "hoedown", kind = "static")]
 121 extern {
 122     fn hoedown_html_renderer_new(render_flags: libc::c_uint,
 123                                  nesting_level: libc::c_int)
 124         -> *mut hoedown_renderer;
 125     fn hoedown_html_renderer_free(renderer: *mut hoedown_renderer);
 126
 127     fn hoedown_document_new(rndr: *mut hoedown_renderer,
 128                             extensions: libc::c_uint,
 129                             max_nesting: libc::size_t) -> *mut hoedown_document;
 130     fn hoedown_document_render(doc: *mut hoedown_document,
 131                                ob: *mut hoedown_buffer,
 132                                document: *const u8,
 133                                doc_size: libc::size_t);
 134     fn hoedown_document_free(md: *mut hoedown_document);
 135
 136     fn hoedown_buffer_new(unit: libc::size_t) -> *mut hoedown_buffer;
 137     fn hoedown_buffer_puts(b: *mut hoedown_buffer, c: *const libc::c_char);
 138     fn hoedown_buffer_free(b: *mut hoedown_buffer);
 139
 140 }
 141
 142 /// Returns Some(code) if `s` is a line that should be stripped from
 143 /// documentation but used in example code. `code` is the portion of
 144 /// `s` that should be used in tests. (None for lines that should be
 145 /// left as-is.)
 146 fn stripped_filtered_line<'a>(s: &'a str) -> Option<&'a str> {
 147     let trimmed = s.trim();
 148     if trimmed.starts_with("# ") {
 149         Some(trimmed.slice_from(2))
 150     } else {
 151         None
 152     }
 153 }
 154
 155 thread_local!(static USED_HEADER_MAP: RefCell<HashMap<String, uint>> = {
 156     RefCell::new(HashMap::new())
 157 });
 158 thread_local!(static TEST_IDX: Cell<uint> = Cell::new(0));
 159
 160 thread_local!(pub static PLAYGROUND_KRATE: RefCell<Option<Option<String>>> = {
 161     RefCell::new(None)
 162 });
 163
 164 pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
 165     extern fn block(ob: *mut hoedown_buffer, orig_text: *const hoedown_buffer,
 166                     lang: *const hoedown_buffer, opaque: *mut libc::c_void) {
 167         unsafe {
 168             if orig_text.is_null() { return }
 169
 170             let opaque = opaque as *mut hoedown_html_renderer_state;
 171             let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque);
 172             let text = slice::from_raw_buf(&(*orig_text).data,
 173                                            (*orig_text).size as uint);
 174             let origtext = str::from_utf8(text).unwrap();
 175             debug!("docblock: ==============\n{:?}\n=======", text);
 176             let rendered = if lang.is_null() {
 177                 false
 178             } else {
 179                 let rlang = slice::from_raw_buf(&(*lang).data,
 180                                                 (*lang).size as uint);
 181                 let rlang = str::from_utf8(rlang).unwrap();
 182                 if !LangString::parse(rlang).rust {
 183                     (my_opaque.dfltblk)(ob, orig_text, lang,
 184                                         opaque as *mut libc::c_void);
 185                     true
 186                 } else {
 187                     false
 188                 }
 189             };
 190
 191             let lines = origtext.lines().filter(|l| {
 192                 stripped_filtered_line(*l).is_none()
 193             });
 194             let text = lines.collect::<Vec<&str>>().connect("\n");
 195             if rendered { return }
 196             PLAYGROUND_KRATE.with(|krate| {
 197                 let mut s = String::new();
 198                 let id = krate.borrow().as_ref().map(|krate| {
 199                     let idx = TEST_IDX.with(|slot| {
 200                         let i = slot.get();
 201                         slot.set(i + 1);
 202                         i
 203                     });
 204
 205                     let test = origtext.lines().map(|l| {
 206                         stripped_filtered_line(l).unwrap_or(l)
 207                     }).collect::<Vec<&str>>().connect("\n");
 208                     let krate = krate.as_ref().map(|s| s.as_slice());
 209                     let test = test::maketest(test.as_slice(), krate, false, false);
 210                     s.push_str(format!("<span id='rust-example-raw-{}' \
 211                                          class='rusttest'>{}</span>",
 212                                        idx, Escape(test.as_slice())).as_slice());
 213                     format!("rust-example-rendered-{}", idx)
 214                 });
 215                 let id = id.as_ref().map(|a| a.as_slice());
 216                 s.push_str(highlight::highlight(text.as_slice(), None, id)
 217                                      .as_slice());
 218                 let output = CString::from_vec(s.into_bytes());
 219                 hoedown_buffer_puts(ob, output.as_ptr());
 220             })
 221         }
 222     }
 223
 224     extern fn header(ob: *mut hoedown_buffer, text: *const hoedown_buffer,
 225                      level: libc::c_int, opaque: *mut libc::c_void) {
 226         // hoedown does this, we may as well too
 227         unsafe { hoedown_buffer_puts(ob, "\n\0".as_ptr() as *const _); }
 228
 229         // Extract the text provided
 230         let s = if text.is_null() {
 231             "".to_string()
 232         } else {
 233             let s = unsafe {
 234                 slice::from_raw_buf(&(*text).data, (*text).size as uint)
 235             };
 236             str::from_utf8(s).unwrap().to_string()
 237         };
 238
 239         // Transform the contents of the header into a hyphenated string
 240         let id = s.words().map(|s| s.to_ascii_lowercase())
 241             .collect::<Vec<String>>().connect("-");
 242
 243         // This is a terrible hack working around how hoedown gives us rendered
 244         // html for text rather than the raw text.
 245
 246         let opaque = opaque as *mut hoedown_html_renderer_state;
 247         let opaque = unsafe { &mut *((*opaque).opaque as *mut MyOpaque) };
 248
 249         // Make sure our hyphenated ID is unique for this page
 250         let id = USED_HEADER_MAP.with(|map| {
 251             let id = id.replace("<code>", "").replace("</code>", "").to_string();
 252             let id = match map.borrow_mut().get_mut(&id) {
 253                 None => id,
 254                 Some(a) => { *a += 1; format!("{}-{}", id, *a - 1) }
 255             };
 256             map.borrow_mut().insert(id.clone(), 1);
 257             id
 258         });
 259
 260         let sec = match opaque.toc_builder {
 261             Some(ref mut builder) => {
 262                 builder.push(level as u32, s.clone(), id.clone())
 263             }
 264             None => {""}
 265         };
 266
 267         // Render the HTML
 268         let text = format!(r##"<h{lvl} id="{id}" class='section-header'><a
 269                            href="#{id}">{sec}{}</a></h{lvl}>"##,
 270                            s, lvl = level, id = id,
 271                            sec = if sec.len() == 0 {
 272                                sec.to_string()
 273                            } else {
 274                                format!("{} ", sec)
 275                            });
 276
 277         let text = CString::from_vec(text.into_bytes());
 278         unsafe { hoedown_buffer_puts(ob, text.as_ptr()) }
 279     }
 280
 281     reset_headers();
 282
 283     unsafe {
 284         let ob = hoedown_buffer_new(DEF_OUNIT);
 285         let renderer = hoedown_html_renderer_new(0, 0);
 286         let mut opaque = MyOpaque {
 287             dfltblk: (*renderer).blockcode.unwrap(),
 288             toc_builder: if print_toc {Some(TocBuilder::new())} else {None}
 289         };
 290         (*(*renderer).opaque).opaque = &mut opaque as *mut _ as *mut libc::c_void;
 291         (*renderer).blockcode = Some(block as blockcodefn);
 292         (*renderer).header = Some(header as headerfn);
 293
 294         let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
 295         hoedown_document_render(document, ob, s.as_ptr(),
 296                                 s.len() as libc::size_t);
 297         hoedown_document_free(document);
 298
 299         hoedown_html_renderer_free(renderer);
 300
 301         let mut ret = match opaque.toc_builder {
 302             Some(b) => write!(w, "<nav id=\"TOC\">{}</nav>", b.into_toc()),
 303             None => Ok(())
 304         };
 305
 306         if ret.is_ok() {
 307             let buf = slice::from_raw_buf(&(*ob).data, (*ob).size as uint);
 308             ret = w.write_str(str::from_utf8(buf).unwrap());
 309         }
 310         hoedown_buffer_free(ob);
 311         ret
 312     }
 313 }
 314
 315 pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
 316     extern fn block(_ob: *mut hoedown_buffer,
 317                     text: *const hoedown_buffer,
 318                     lang: *const hoedown_buffer,
 319                     opaque: *mut libc::c_void) {
 320         unsafe {
 321             if text.is_null() { return }
 322             let block_info = if lang.is_null() {
 323                 LangString::all_false()
 324             } else {
 325                 let lang = slice::from_raw_buf(&(*lang).data,
 326                                                (*lang).size as uint);
 327                 let s = str::from_utf8(lang).unwrap();
 328                 LangString::parse(s)
 329             };
 330             if !block_info.rust { return }
 331             let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
 332             let opaque = opaque as *mut hoedown_html_renderer_state;
 333             let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
 334             let text = str::from_utf8(text).unwrap();
 335             let lines = text.lines().map(|l| {
 336                 stripped_filtered_line(l).unwrap_or(l)
 337             });
 338             let text = lines.collect::<Vec<&str>>().connect("\n");
 339             tests.add_test(text.to_string(),
 340                            block_info.should_fail, block_info.no_run,
 341                            block_info.ignore, block_info.test_harness);
 342         }
 343     }
 344
 345     extern fn header(_ob: *mut hoedown_buffer,
 346                      text: *const hoedown_buffer,
 347                      level: libc::c_int, opaque: *mut libc::c_void) {
 348         unsafe {
 349             let opaque = opaque as *mut hoedown_html_renderer_state;
 350             let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
 351             if text.is_null() {
 352                 tests.register_header("", level as u32);
 353             } else {
 354                 let text = slice::from_raw_buf(&(*text).data, (*text).size as uint);
 355                 let text = str::from_utf8(text).unwrap();
 356                 tests.register_header(text, level as u32);
 357             }
 358         }
 359     }
 360
 361     unsafe {
 362         let ob = hoedown_buffer_new(DEF_OUNIT);
 363         let renderer = hoedown_html_renderer_new(0, 0);
 364         (*renderer).blockcode = Some(block as blockcodefn);
 365         (*renderer).header = Some(header as headerfn);
 366         (*(*renderer).opaque).opaque = tests as *mut _ as *mut libc::c_void;
 367
 368         let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
 369         hoedown_document_render(document, ob, doc.as_ptr(),
 370                                 doc.len() as libc::size_t);
 371         hoedown_document_free(document);
 372
 373         hoedown_html_renderer_free(renderer);
 374         hoedown_buffer_free(ob);
 375     }
 376 }
 377
 378 #[derive(Eq, PartialEq, Clone, Show)]
 379 struct LangString {
 380     should_fail: bool,
 381     no_run: bool,
 382     ignore: bool,
 383     rust: bool,
 384     test_harness: bool,
 385 }
 386
 387 impl LangString {
 388     fn all_false() -> LangString {
 389         LangString {
 390             should_fail: false,
 391             no_run: false,
 392             ignore: false,
 393             rust: true,  // NB This used to be `notrust = false`
 394             test_harness: false,
 395         }
 396     }
 397
 398     fn parse(string: &str) -> LangString {
 399         let mut seen_rust_tags = false;
 400         let mut seen_other_tags = false;
 401         let mut data = LangString::all_false();
 402
 403         let mut tokens = string.split(|&: c: char|
 404             !(c == '_' || c == '-' || c.is_alphanumeric())
 405         );
 406
 407         for token in tokens {
 408             match token {
 409                 "" => {},
 410                 "should_fail" => { data.should_fail = true; seen_rust_tags = true; },
 411                 "no_run" => { data.no_run = true; seen_rust_tags = true; },
 412                 "ignore" => { data.ignore = true; seen_rust_tags = true; },
 413                 "rust" => { data.rust = true; seen_rust_tags = true; },
 414                 "test_harness" => { data.test_harness = true; seen_rust_tags = true; }
 415                 _ => { seen_other_tags = true }
 416             }
 417         }
 418
 419         data.rust &= !seen_other_tags || seen_rust_tags;
 420
 421         data
 422     }
 423 }
 424
 425 /// By default this markdown renderer generates anchors for each header in the
 426 /// rendered document. The anchor name is the contents of the header separated
 427 /// by hyphens, and a task-local map is used to disambiguate among duplicate
 428 /// headers (numbers are appended).
 429 ///
 430 /// This method will reset the local table for these headers. This is typically
 431 /// used at the beginning of rendering an entire HTML page to reset from the
 432 /// previous state (if any).
 433 pub fn reset_headers() {
 434     USED_HEADER_MAP.with(|s| s.borrow_mut().clear());
 435     TEST_IDX.with(|s| s.set(0));
 436 }
 437
 438 //NOTE(stage0): remove impl after snapshot
 439 #[cfg(stage0)]
 440 impl<'a> fmt::Show for Markdown<'a> {
 441     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 442         fmt::String::fmt(self, f)
 443     }
 444 }
 445
 446 impl<'a> fmt::String for Markdown<'a> {
 447     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 448         let Markdown(md) = *self;
 449         // This is actually common enough to special-case
 450         if md.len() == 0 { return Ok(()) }
 451         render(fmt, md.as_slice(), false)
 452     }
 453 }
 454
 455 //NOTE(stage0): remove impl after snapshot
 456 #[cfg(stage0)]
 457 impl<'a> fmt::Show for MarkdownWithToc<'a> {
 458     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 459         fmt::String::fmt(self, f)
 460     }
 461 }
 462
 463 impl<'a> fmt::String for MarkdownWithToc<'a> {
 464     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 465         let MarkdownWithToc(md) = *self;
 466         render(fmt, md.as_slice(), true)
 467     }
 468 }
 469
 470 #[cfg(test)]
 471 mod tests {
 472     use super::{LangString, Markdown};
 473
 474     #[test]
 475     fn test_lang_string_parse() {
 476         fn t(s: &str,
 477             should_fail: bool, no_run: bool, ignore: bool, rust: bool, test_harness: bool) {
 478             assert_eq!(LangString::parse(s), LangString {
 479                 should_fail: should_fail,
 480                 no_run: no_run,
 481                 ignore: ignore,
 482                 rust: rust,
 483                 test_harness: test_harness,
 484             })
 485         }
 486
 487         // marker                | should_fail | no_run | ignore | rust | test_harness
 488         t("",                      false,        false,   false,   true,  false);
 489         t("rust",                  false,        false,   false,   true,  false);
 490         t("sh",                    false,        false,   false,   false, false);
 491         t("ignore",                false,        false,   true,    true,  false);
 492         t("should_fail",           true,         false,   false,   true,  false);
 493         t("no_run",                false,        true,    false,   true,  false);
 494         t("test_harness",          false,        false,   false,   true,  true);
 495         t("{.no_run .example}",    false,        true,    false,   true,  false);
 496         t("{.sh .should_fail}",    true,         false,   false,   true,  false);
 497         t("{.example .rust}",      false,        false,   false,   true,  false);
 498         t("{.test_harness .rust}", false,        false,   false,   true,  true);
 499     }
 500
 501     #[test]
 502     fn issue_17736() {
 503         let markdown = "# title";
 504         format!("{}", Markdown(markdown.as_slice()));
 505     }
 506 }