bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add missing markdown tags

Browse source
This commit is contained in:
Guillaume Gomez 2017-03-11 01:43:36 +01:00
parent f6baea23ba
commit d5b6c046de
4 changed files with 251 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

259
src/librustdoc/html/markdown.rs
View file

@ -26,13 +26,10 @@
#![allow(non_camel_case_types)]
//use libc;
use std::ascii::AsciiExt;
use std::cell::RefCell;
use std::default::Default;
//use std::ffi::CString;
use std::fmt::{self, Write};
//use std::slice;
use std::str;
use syntax::feature_gate::UnstableFeatures;
use syntax::codemap::Span;
@ -45,11 +42,33 @@ use test;
use pulldown_cmark::{self, Event, Parser, Tag};
#[derive(Copy, Clone)]
pub enum MarkdownOutputStyle {
Compact,
Fancy,
}
impl MarkdownOutputStyle {
pub fn is_compact(&self) -> bool {
match *self {
MarkdownOutputStyle::Compact => true,
_ => false,
}
}
pub fn is_fancy(&self) -> bool {
match *self {
MarkdownOutputStyle::Fancy => true,
_ => false,
}
}
}
/// A unit struct which has the `fmt::Display` trait implemented. When
/// formatted, this struct will emit the HTML corresponding to the rendered
/// version of the contained markdown string.
// The second parameter is whether we need a shorter version or not.
pub struct Markdown<'a>(pub &'a str, pub bool);
pub struct Markdown<'a>(pub &'a str, pub MarkdownOutputStyle);
/// A unit struct like `Markdown`, that renders the markdown with a
/// table of contents.
pub struct MarkdownWithToc<'a>(pub &'a str);
@ -85,16 +104,13 @@ thread_local!(pub static PLAYGROUND: RefCell<Option<(Option<String>, String)>> =
RefCell::new(None)
});
pub fn render(w: &mut fmt::Formatter,
s: &str,
print_toc: bool,
shorter: bool) -> fmt::Result {
shorter: MarkdownOutputStyle) -> fmt::Result {
fn block(parser: &mut Parser, buffer: &mut String, lang: &str) {
let mut origtext = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::CodeBlock(_)) => break,
Event::Text(ref s) => {
@ -102,9 +118,6 @@ pub fn render(w: &mut fmt::Formatter,
}
_ => {}
}
} else {
break
}
}
let origtext = origtext.trim_left();
debug!("docblock: ==============\n{:?}\n=======", origtext);
@ -176,20 +189,19 @@ pub fn render(w: &mut fmt::Formatter,
fn header(parser: &mut Parser, level: i32, toc_builder: &mut Option<TocBuilder>,
buffer: &mut String) {
let mut ret = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Header(_)) => break,
Event::Text(ref s) => {
ret.push_str(s);
}
Event::SoftBreak | Event::HardBreak if !ret.is_empty() => {
ret.push(' ');
}
_ => {}
}
} else {
break
}
}
ret = ret.trim_right().to_owned();
let id = ret.clone();
// Discard '<em>', '<code>' tags and some escaped characters,
@ -226,69 +238,64 @@ pub fn render(w: &mut fmt::Formatter,
fn codespan(parser: &mut Parser, buffer: &mut String) {
let mut content = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Code) => break,
Event::Text(ref s) => {
content.push_str(s);
}
Event::SoftBreak | Event::HardBreak if !content.is_empty() => {
content.push(' ');
}
_ => {}
}
} else {
break
}
}
buffer.push_str(&format!("<code>{}</code>", Escape(&collapse_whitespace(&content))));
buffer.push_str(&format!("<code>{}</code>", Escape(&collapse_whitespace(content.trim_right()))));
}
fn link(parser: &mut Parser, buffer: &mut String, url: &str, mut title: String) {
loop {
let event = parser.next();
if let Some(event) = event {
fn link(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: MarkdownOutputStyle, url: &str, mut title: String) {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Link(_, _)) => break,
Event::Text(ref s) => {
title.push_str(s);
}
_ => {}
Event::SoftBreak | Event::HardBreak if !title.is_empty() => {
title.push(' ');
}
x => {
looper(parser, &mut title, Some(x), toc_builder, shorter);
}
} else {
break
}
}
buffer.push_str(&format!("<a href=\"{}\">{}</a>", url, title));
}
fn paragraph(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: bool) {
shorter: MarkdownOutputStyle) {
let mut content = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Paragraph) => break,
Event::Text(ref s) => {
content.push_str(s);
}
Event::SoftBreak | Event::HardBreak if !content.is_empty() => {
content.push(' ');
}
x => {
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
} else {
break
}
}
buffer.push_str(&format!("<p>{}</p>", content));
buffer.push_str(&format!("<p>{}</p>", content.trim_right()));
}
fn cell(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: bool) {
shorter: MarkdownOutputStyle) {
let mut content = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::TableHead) |
Event::End(Tag::Table(_)) |
@ -297,23 +304,21 @@ pub fn render(w: &mut fmt::Formatter,
Event::Text(ref s) => {
content.push_str(s);
}
Event::SoftBreak | Event::HardBreak => {
content.push(' ');
}
x => {
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
} else {
break
}
}
buffer.push_str(&format!("<td>{}</td>", content.trim()));
}
fn row(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: bool) {
shorter: MarkdownOutputStyle) {
let mut content = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::TableHead) |
Event::End(Tag::Table(_)) |
@ -325,19 +330,14 @@ pub fn render(w: &mut fmt::Formatter,
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
} else {
break
}
}
buffer.push_str(&format!("<tr>{}</tr>", content));
}
fn head(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: bool) {
shorter: MarkdownOutputStyle) {
let mut content = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::TableHead) | Event::End(Tag::Table(_)) => break,
Event::Start(Tag::TableCell) => {
@ -347,23 +347,17 @@ pub fn render(w: &mut fmt::Formatter,
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
} else {
break
}
}
if content.is_empty() {
return
}
if !content.is_empty() {
buffer.push_str(&format!("<thead><tr>{}</tr></thead>", content.replace("td>", "th>")));
}
}
fn table(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: bool) {
shorter: MarkdownOutputStyle) {
let mut content = String::new();
let mut rows = String::new();
loop {
let event = parser.next();
if let Some(event) = event {
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Table(_)) => break,
Event::Start(Tag::TableHead) => {
@ -374,21 +368,112 @@ pub fn render(w: &mut fmt::Formatter,
}
_ => {}
}
} else {
break
}
}
buffer.push_str(&format!("<table>{}{}</table>",
content,
if shorter || rows.is_empty() {
if shorter.is_compact() || rows.is_empty() {
String::new()
} else {
format!("<tbody>{}</tbody>", rows)
}));
}
fn blockquote(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: MarkdownOutputStyle) {
let mut content = String::new();
while let Some(event) = parser.next() {
match event {
Event::End(Tag::BlockQuote) => break,
Event::Text(ref s) => {
content.push_str(s);
}
Event::SoftBreak | Event::HardBreak if !content.is_empty() => {
content.push(' ');
}
x => {
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
}
buffer.push_str(&format!("<blockquote>{}</blockquote>", content.trim_right()));
}
fn list_item(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: MarkdownOutputStyle) {
let mut content = String::new();
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Item) => break,
Event::Text(ref s) => {
content.push_str(s);
}
x => {
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
}
buffer.push_str(&format!("<li>{}</li>", content));
}
fn list(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: MarkdownOutputStyle) {
let mut content = String::new();
while let Some(event) = parser.next() {
match event {
Event::End(Tag::List(_)) => break,
Event::Start(Tag::Item) => {
list_item(parser, &mut content, toc_builder, shorter);
}
x => {
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
}
buffer.push_str(&format!("<ul>{}</ul>", content));
}
fn emphasis(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: MarkdownOutputStyle) {
let mut content = String::new();
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Emphasis) => break,
Event::Text(ref s) => {
content.push_str(s);
}
Event::SoftBreak | Event::HardBreak if !content.is_empty() => {
content.push(' ');
}
x => {
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
}
buffer.push_str(&format!("<em>{}</em>", content));
}
fn strong(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
shorter: MarkdownOutputStyle) {
let mut content = String::new();
while let Some(event) = parser.next() {
match event {
Event::End(Tag::Strong) => break,
Event::Text(ref s) => {
content.push_str(s);
}
Event::SoftBreak | Event::HardBreak if !content.is_empty() => {
content.push(' ');
}
x => {
looper(parser, &mut content, Some(x), toc_builder, shorter);
}
}
}
buffer.push_str(&format!("<strong>{}</strong>", content));
}
fn looper<'a>(parser: &'a mut Parser, buffer: &mut String, next_event: Option<Event<'a>>,
toc_builder: &mut Option<TocBuilder>, shorter: bool) -> bool {
toc_builder: &mut Option<TocBuilder>, shorter: MarkdownOutputStyle) -> bool {
if let Some(event) = next_event {
match event {
Event::Start(Tag::CodeBlock(lang)) => {
@ -404,14 +489,26 @@ pub fn render(w: &mut fmt::Formatter,
paragraph(parser, buffer, toc_builder, shorter);
}
Event::Start(Tag::Link(ref url, ref t)) => {
link(parser, buffer, url, t.as_ref().to_owned());
link(parser, buffer, toc_builder, shorter, url, t.as_ref().to_owned());
}
Event::Start(Tag::Table(_)) => {
table(parser, buffer, toc_builder, shorter);
}
Event::Start(Tag::BlockQuote) => {
blockquote(parser, buffer, toc_builder, shorter);
}
Event::Start(Tag::List(_)) => {
list(parser, buffer, toc_builder, shorter);
}
Event::Start(Tag::Emphasis) => {
emphasis(parser, buffer, toc_builder, shorter);
}
Event::Start(Tag::Strong) => {
strong(parser, buffer, toc_builder, shorter);
}
_ => {}
}
shorter == false
shorter.is_fancy()
} else {
false
}
@ -594,7 +691,7 @@ impl<'a> fmt::Display for Markdown<'a> {
impl<'a> fmt::Display for MarkdownWithToc<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let MarkdownWithToc(md) = *self;
render(fmt, md, true, false)
render(fmt, md, true, MarkdownOutputStyle::Fancy)
}
}
@ -603,7 +700,7 @@ impl<'a> fmt::Display for MarkdownHtml<'a> {
let MarkdownHtml(md) = *self;
// This is actually common enough to special-case
if md.is_empty() { return Ok(()) }
render(fmt, md, false, false)
render(fmt, md, false, MarkdownOutputStyle::Fancy)
}
}
@ -660,7 +757,7 @@ pub fn plain_summary_line(md: &str) -> String {
#[cfg(test)]
mod tests {
use super::{LangString, Markdown, MarkdownHtml};
use super::{LangString, Markdown, MarkdownHtml, MarkdownOutputStyle};
use super::plain_summary_line;
use html::render::reset_ids;
@ -700,14 +797,14 @@ mod tests {
#[test]
fn issue_17736() {
let markdown = "# title";
format!("{}", Markdown(markdown));
format!("{}", Markdown(markdown, MarkdownOutputStyle::Fancy));
reset_ids(true);
}
#[test]
fn test_header() {
fn t(input: &str, expect: &str) {
let output = format!("{}", Markdown(input));
let output = format!("{}", Markdown(input, MarkdownOutputStyle::Fancy));
assert_eq!(output, expect);
reset_ids(true);
}
@ -729,7 +826,7 @@ mod tests {
#[test]
fn test_header_ids_multiple_blocks() {
fn t(input: &str, expect: &str) {
let output = format!("{}", Markdown(input));
let output = format!("{}", Markdown(input, MarkdownOutputStyle::Fancy));
assert_eq!(output, expect);
}

13
src/librustdoc/html/render.rs
View file

@ -72,7 +72,7 @@ use html::format::{TyParamBounds, WhereClause, href, AbiSpace};
use html::format::{VisSpace, Method, UnsafetySpace, MutableSpace};
use html::format::fmt_impl_for_trait_page;
use html::item_type::ItemType;
use html::markdown::{self, Markdown, MarkdownHtml};
use html::markdown::{self, Markdown, MarkdownHtml, MarkdownOutputStyle};
use html::{highlight, layout};
/// A pair of name and its optional document.
@ -1650,7 +1650,8 @@ fn document_short(w: &mut fmt::Formatter, item: &clean::Item, link: AssocItemLin
} else {
format!("{}", &plain_summary_line(Some(s)))
};
write!(w, "<div class='docblock'>{}</div>", Markdown(&markdown, false))?;
write!(w, "<div class='docblock'>{}</div>",
Markdown(&markdown, MarkdownOutputStyle::Fancy))?;
}
Ok(())
}
@ -1683,7 +1684,8 @@ fn get_doc_value(item: &clean::Item) -> Option<&str> {
fn document_full(w: &mut fmt::Formatter, item: &clean::Item) -> fmt::Result {
if let Some(s) = get_doc_value(item) {
write!(w, "<div class='docblock'>{}</div>",
Markdown(&format!("{}{}", md_render_assoc_item(item), s), false))?;
Markdown(&format!("{}{}", md_render_assoc_item(item), s),
MarkdownOutputStyle::Fancy))?;
}
Ok(())
}
@ -1871,7 +1873,8 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
</tr>",
name = *myitem.name.as_ref().unwrap(),
stab_docs = stab_docs,
docs = shorter(Some(&Markdown(doc_value, true).to_string())),
docs = shorter(Some(&Markdown(doc_value,
MarkdownOutputStyle::Compact).to_string())),
class = myitem.type_(),
stab = myitem.stability_class().unwrap_or("".to_string()),
unsafety_flag = unsafety_flag,
@ -2901,7 +2904,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
write!(w, "</span>")?;
write!(w, "</h3>\n")?;
if let Some(ref dox) = i.impl_item.doc_value() {
write!(w, "<div class='docblock'>{}</div>", Markdown(dox, false))?;
write!(w, "<div class='docblock'>{}</div>", Markdown(dox, MarkdownOutputStyle::Fancy))?;
}
}

4
src/librustdoc/markdown.rs
View file

@ -25,7 +25,7 @@ use externalfiles::{ExternalHtml, LoadStringError, load_string};
use html::render::reset_ids;
use html::escape::Escape;
use html::markdown;
use html::markdown::{Markdown, MarkdownWithToc, find_testable_code};
use html::markdown::{Markdown, MarkdownWithToc, MarkdownOutputStyle, find_testable_code};
use test::{TestOptions, Collector};
/// Separate any lines at the start of the file that begin with `%`.
@ -94,7 +94,7 @@ pub fn render(input: &str, mut output: PathBuf, matches: &getopts::Matches,
let rendered = if include_toc {
format!("{}", MarkdownWithToc(text))
} else {
format!("{}", Markdown(text, false))
format!("{}", Markdown(text, MarkdownOutputStyle::Fancy))
};
let err = write!(

4
src/tools/error_index_generator/main.rs
View file

@ -24,7 +24,7 @@ use std::path::PathBuf;
use syntax::diagnostics::metadata::{get_metadata_dir, ErrorMetadataMap, ErrorMetadata};
use rustdoc::html::markdown::{Markdown, PLAYGROUND};
use rustdoc::html::markdown::{Markdown, MarkdownOutputStyle, PLAYGROUND};
use rustc_serialize::json;
enum OutputFormat {
@ -100,7 +100,7 @@ impl Formatter for HTMLFormatter {
// Description rendered as markdown.
match info.description {
Some(ref desc) => write!(output, "{}", Markdown(desc, false))?,
Some(ref desc) => write!(output, "{}", Markdown(desc, MarkdownOutputStyle::Fancy))?,
None => write!(output, "<p>No description.</p>\n")?,
}