Rollup merge of #52628 - Mark-Simulacrum:rustdoc-cleanup-1, r=QuietMisdreavus
Cleanup some rustdoc code Commits are mostly individual though some do depend on others.
This commit is contained in:
Pietro Albini
GitHub
commit
03df573c57
|
|
@ -12,7 +12,9 @@ use std::fs;
|
|||
use std::path::Path;
|
||||
use std::str;
|
||||
use errors;
|
||||
use html::markdown::Markdown;
|
||||
use syntax::feature_gate::UnstableFeatures;
|
||||
use html::markdown::{IdMap, ErrorCodes, Markdown};
|
||||
use std::cell::RefCell;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct ExternalHtml {
|
||||
|
|
@ -29,8 +31,10 @@ pub struct ExternalHtml {
|
|||
|
||||
impl ExternalHtml {
|
||||
pub fn load(in_header: &[String], before_content: &[String], after_content: &[String],
|
||||
md_before_content: &[String], md_after_content: &[String], diag: &errors::Handler)
|
||||
md_before_content: &[String], md_after_content: &[String], diag: &errors::Handler,
|
||||
id_map: &mut IdMap)
|
||||
-> Option<ExternalHtml> {
|
||||
let codes = ErrorCodes::from(UnstableFeatures::from_environment().is_nightly_build());
|
||||
load_external_files(in_header, diag)
|
||||
.and_then(|ih|
|
||||
load_external_files(before_content, diag)
|
||||
|
|
@ -38,7 +42,8 @@ impl ExternalHtml {
|
|||
)
|
||||
.and_then(|(ih, bc)|
|
||||
load_external_files(md_before_content, diag)
|
||||
.map(|m_bc| (ih, format!("{}{}", bc, Markdown(&m_bc, &[]))))
|
||||
.map(|m_bc| (ih,
|
||||
format!("{}{}", bc, Markdown(&m_bc, &[], RefCell::new(id_map), codes))))
|
||||
)
|
||||
.and_then(|(ih, bc)|
|
||||
load_external_files(after_content, diag)
|
||||
|
|
@ -46,7 +51,8 @@ impl ExternalHtml {
|
|||
)
|
||||
.and_then(|(ih, bc, ac)|
|
||||
load_external_files(md_after_content, diag)
|
||||
.map(|m_ac| (ih, bc, format!("{}{}", ac, Markdown(&m_ac, &[]))))
|
||||
.map(|m_ac| (ih, bc,
|
||||
format!("{}{}", ac, Markdown(&m_ac, &[], RefCell::new(id_map), codes))))
|
||||
)
|
||||
.map(|(ih, bc, ac)|
|
||||
ExternalHtml {
|
||||
|
|
|
|||
|
|
@ -13,12 +13,7 @@
|
|||
//! This module uses libsyntax's lexer to provide token-based highlighting for
|
||||
//! the HTML documentation generated by rustdoc.
|
||||
//!
|
||||
//! If you just want to syntax highlighting for a Rust program, then you can use
|
||||
//! the `render_inner_with_highlighting` or `render_with_highlighting`
|
||||
//! functions. For more advanced use cases (if you want to supply your own css
|
||||
//! classes or control how the HTML is generated, or even generate something
|
||||
//! other then HTML), then you should implement the `Writer` trait and use a
|
||||
//! `Classifier`.
|
||||
//! Use the `render_with_highlighting` to highlight some rust code.
|
||||
|
||||
use html::escape::Escape;
|
||||
|
||||
|
|
@ -33,7 +28,7 @@ use syntax::parse;
|
|||
use syntax_pos::{Span, FileName};
|
||||
|
||||
/// Highlights `src`, returning the HTML output.
|
||||
pub fn render_with_highlighting(src: &str, class: Option<&str>, id: Option<&str>,
|
||||
pub fn render_with_highlighting(src: &str, class: Option<&str>,
|
||||
extension: Option<&str>,
|
||||
tooltip: Option<(&str, &str)>) -> String {
|
||||
debug!("highlighting: ================\n{}\n==============", src);
|
||||
|
|
@ -46,7 +41,7 @@ pub fn render_with_highlighting(src: &str, class: Option<&str>, id: Option<&str>
|
|||
class='tooltiptext'>{}</span></div></div>",
|
||||
class, tooltip).unwrap();
|
||||
}
|
||||
write_header(class, id, &mut out).unwrap();
|
||||
write_header(class, &mut out).unwrap();
|
||||
|
||||
let mut classifier = Classifier::new(lexer::StringReader::new(&sess, fm, None), sess.codemap());
|
||||
if let Err(_) = classifier.write_source(&mut out) {
|
||||
|
|
@ -63,7 +58,7 @@ pub fn render_with_highlighting(src: &str, class: Option<&str>, id: Option<&str>
|
|||
/// Processes a program (nested in the internal `lexer`), classifying strings of
|
||||
/// text by highlighting category (`Class`). Calls out to a `Writer` to write
|
||||
/// each span of text in sequence.
|
||||
pub struct Classifier<'a> {
|
||||
struct Classifier<'a> {
|
||||
lexer: lexer::StringReader<'a>,
|
||||
codemap: &'a CodeMap,
|
||||
|
||||
|
|
@ -75,7 +70,7 @@ pub struct Classifier<'a> {
|
|||
|
||||
/// How a span of text is classified. Mostly corresponds to token kinds.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum Class {
|
||||
enum Class {
|
||||
None,
|
||||
Comment,
|
||||
DocComment,
|
||||
|
|
@ -103,7 +98,7 @@ pub enum Class {
|
|||
/// The classifier will call into the `Writer` implementation as it finds spans
|
||||
/// of text to highlight. Exactly how that text should be highlighted is up to
|
||||
/// the implementation.
|
||||
pub trait Writer {
|
||||
trait Writer {
|
||||
/// Called when we start processing a span of text that should be highlighted.
|
||||
/// The `Class` argument specifies how it should be highlighted.
|
||||
fn enter_span(&mut self, _: Class) -> io::Result<()>;
|
||||
|
|
@ -111,11 +106,9 @@ pub trait Writer {
|
|||
/// Called at the end of a span of highlighted text.
|
||||
fn exit_span(&mut self) -> io::Result<()>;
|
||||
|
||||
/// Called for a span of text, usually, but not always, a single token. If
|
||||
/// the string of text (`T`) does correspond to a token, then the token will
|
||||
/// also be passed. If the text should be highlighted differently from the
|
||||
/// surrounding text, then the `Class` argument will be a value other than
|
||||
/// `None`.
|
||||
/// Called for a span of text. If the text should be highlighted differently from the
|
||||
/// surrounding text, then the `Class` argument will be a value other than `None`.
|
||||
///
|
||||
/// The following sequences of callbacks are equivalent:
|
||||
/// ```plain
|
||||
/// enter_span(Foo), string("text", None), exit_span()
|
||||
|
|
@ -125,8 +118,7 @@ pub trait Writer {
|
|||
/// more flexible.
|
||||
fn string<T: Display>(&mut self,
|
||||
text: T,
|
||||
klass: Class,
|
||||
tok: Option<&TokenAndSpan>)
|
||||
klass: Class)
|
||||
-> io::Result<()>;
|
||||
}
|
||||
|
||||
|
|
@ -135,8 +127,7 @@ pub trait Writer {
|
|||
impl<U: Write> Writer for U {
|
||||
fn string<T: Display>(&mut self,
|
||||
text: T,
|
||||
klass: Class,
|
||||
_tas: Option<&TokenAndSpan>)
|
||||
klass: Class)
|
||||
-> io::Result<()> {
|
||||
match klass {
|
||||
Class::None => write!(self, "{}", text),
|
||||
|
|
@ -154,7 +145,7 @@ impl<U: Write> Writer for U {
|
|||
}
|
||||
|
||||
impl<'a> Classifier<'a> {
|
||||
pub fn new(lexer: lexer::StringReader<'a>, codemap: &'a CodeMap) -> Classifier<'a> {
|
||||
fn new(lexer: lexer::StringReader<'a>, codemap: &'a CodeMap) -> Classifier<'a> {
|
||||
Classifier {
|
||||
lexer,
|
||||
codemap,
|
||||
|
|
@ -186,7 +177,7 @@ impl<'a> Classifier<'a> {
|
|||
/// is used. All source code emission is done as slices from the source map,
|
||||
/// not from the tokens themselves, in order to stay true to the original
|
||||
/// source.
|
||||
pub fn write_source<W: Writer>(&mut self,
|
||||
fn write_source<W: Writer>(&mut self,
|
||||
out: &mut W)
|
||||
-> io::Result<()> {
|
||||
loop {
|
||||
|
|
@ -208,7 +199,7 @@ impl<'a> Classifier<'a> {
|
|||
-> io::Result<()> {
|
||||
let klass = match tas.tok {
|
||||
token::Shebang(s) => {
|
||||
out.string(Escape(&s.as_str()), Class::None, Some(&tas))?;
|
||||
out.string(Escape(&s.as_str()), Class::None)?;
|
||||
return Ok(());
|
||||
},
|
||||
|
||||
|
|
@ -272,8 +263,8 @@ impl<'a> Classifier<'a> {
|
|||
self.in_attribute = true;
|
||||
out.enter_span(Class::Attribute)?;
|
||||
}
|
||||
out.string("#", Class::None, None)?;
|
||||
out.string("!", Class::None, None)?;
|
||||
out.string("#", Class::None)?;
|
||||
out.string("!", Class::None)?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
|
|
@ -282,13 +273,13 @@ impl<'a> Classifier<'a> {
|
|||
self.in_attribute = true;
|
||||
out.enter_span(Class::Attribute)?;
|
||||
}
|
||||
out.string("#", Class::None, None)?;
|
||||
out.string("#", Class::None)?;
|
||||
return Ok(());
|
||||
}
|
||||
token::CloseDelim(token::Bracket) => {
|
||||
if self.in_attribute {
|
||||
self.in_attribute = false;
|
||||
out.string("]", Class::None, None)?;
|
||||
out.string("]", Class::None)?;
|
||||
out.exit_span()?;
|
||||
return Ok(());
|
||||
} else {
|
||||
|
|
@ -344,7 +335,7 @@ impl<'a> Classifier<'a> {
|
|||
|
||||
// Anything that didn't return above is the simple case where we the
|
||||
// class just spans a single token, so we can use the `string` method.
|
||||
out.string(Escape(&self.snip(tas.sp)), klass, Some(&tas))
|
||||
out.string(Escape(&self.snip(tas.sp)), klass)
|
||||
}
|
||||
|
||||
// Helper function to get a snippet from the codemap.
|
||||
|
|
@ -355,7 +346,7 @@ impl<'a> Classifier<'a> {
|
|||
|
||||
impl Class {
|
||||
/// Returns the css class expected by rustdoc for each `Class`.
|
||||
pub fn rustdoc_class(self) -> &'static str {
|
||||
fn rustdoc_class(self) -> &'static str {
|
||||
match self {
|
||||
Class::None => "",
|
||||
Class::Comment => "comment",
|
||||
|
|
@ -379,15 +370,8 @@ impl Class {
|
|||
}
|
||||
}
|
||||
|
||||
fn write_header(class: Option<&str>,
|
||||
id: Option<&str>,
|
||||
out: &mut dyn Write)
|
||||
-> io::Result<()> {
|
||||
write!(out, "<pre ")?;
|
||||
if let Some(id) = id {
|
||||
write!(out, "id='{}' ", id)?;
|
||||
}
|
||||
write!(out, "class=\"rust {}\">\n", class.unwrap_or(""))
|
||||
fn write_header(class: Option<&str>, out: &mut dyn Write) -> io::Result<()> {
|
||||
write!(out, "<pre class=\"rust {}\">\n", class.unwrap_or(""))
|
||||
}
|
||||
|
||||
fn write_footer(out: &mut dyn Write) -> io::Result<()> {
|
||||
|
|
|
|||
|
|
@ -18,16 +18,17 @@
|
|||
//! ```
|
||||
//! #![feature(rustc_private)]
|
||||
//!
|
||||
//! use rustdoc::html::markdown::Markdown;
|
||||
//! use rustdoc::html::markdown::{IdMap, Markdown, ErrorCodes};
|
||||
//! use std::cell::RefCell;
|
||||
//!
|
||||
//! let s = "My *markdown* _text_";
|
||||
//! let html = format!("{}", Markdown(s, &[]));
|
||||
//! let mut id_map = IdMap::new();
|
||||
//! let html = format!("{}", Markdown(s, &[], RefCell::new(&mut id_map), ErrorCodes::Yes));
|
||||
//! // ... something using html
|
||||
//! ```
|
||||
|
||||
#![allow(non_camel_case_types)]
|
||||
|
||||
use rustc::session;
|
||||
use std::cell::RefCell;
|
||||
use std::collections::{HashMap, VecDeque};
|
||||
use std::default::Default;
|
||||
|
|
@ -35,10 +36,7 @@ use std::fmt::{self, Write};
|
|||
use std::borrow::Cow;
|
||||
use std::ops::Range;
|
||||
use std::str;
|
||||
use syntax::feature_gate::UnstableFeatures;
|
||||
use syntax::codemap::Span;
|
||||
|
||||
use html::render::derive_id;
|
||||
use html::toc::TocBuilder;
|
||||
use html::highlight;
|
||||
use test;
|
||||
|
|
@ -50,15 +48,38 @@ use pulldown_cmark::{Options, OPTION_ENABLE_FOOTNOTES, OPTION_ENABLE_TABLES};
|
|||
/// formatted, this struct will emit the HTML corresponding to the rendered
|
||||
/// version of the contained markdown string.
|
||||
/// The second parameter is a list of link replacements
|
||||
pub struct Markdown<'a>(pub &'a str, pub &'a [(String, String)]);
|
||||
pub struct Markdown<'a>(
|
||||
pub &'a str, pub &'a [(String, String)], pub RefCell<&'a mut IdMap>, pub ErrorCodes);
|
||||
/// A unit struct like `Markdown`, that renders the markdown with a
|
||||
/// table of contents.
|
||||
pub struct MarkdownWithToc<'a>(pub &'a str);
|
||||
pub struct MarkdownWithToc<'a>(pub &'a str, pub RefCell<&'a mut IdMap>, pub ErrorCodes);
|
||||
/// A unit struct like `Markdown`, that renders the markdown escaping HTML tags.
|
||||
pub struct MarkdownHtml<'a>(pub &'a str);
|
||||
pub struct MarkdownHtml<'a>(pub &'a str, pub RefCell<&'a mut IdMap>, pub ErrorCodes);
|
||||
/// A unit struct like `Markdown`, that renders only the first paragraph.
|
||||
pub struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [(String, String)]);
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Debug)]
|
||||
pub enum ErrorCodes {
|
||||
Yes,
|
||||
No,
|
||||
}
|
||||
|
||||
impl ErrorCodes {
|
||||
pub fn from(b: bool) -> Self {
|
||||
match b {
|
||||
true => ErrorCodes::Yes,
|
||||
false => ErrorCodes::No,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn as_bool(self) -> bool {
|
||||
match self {
|
||||
ErrorCodes::Yes => true,
|
||||
ErrorCodes::No => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Controls whether a line will be hidden or shown in HTML output.
|
||||
///
|
||||
/// All lines are used in documentation tests.
|
||||
|
|
@ -129,12 +150,14 @@ thread_local!(pub static PLAYGROUND: RefCell<Option<(Option<String>, String)>> =
|
|||
/// Adds syntax highlighting and playground Run buttons to rust code blocks.
|
||||
struct CodeBlocks<'a, I: Iterator<Item = Event<'a>>> {
|
||||
inner: I,
|
||||
check_error_codes: ErrorCodes,
|
||||
}
|
||||
|
||||
impl<'a, I: Iterator<Item = Event<'a>>> CodeBlocks<'a, I> {
|
||||
fn new(iter: I) -> Self {
|
||||
fn new(iter: I, error_codes: ErrorCodes) -> Self {
|
||||
CodeBlocks {
|
||||
inner: iter,
|
||||
check_error_codes: error_codes,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -147,7 +170,7 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'a, I> {
|
|||
let compile_fail;
|
||||
let ignore;
|
||||
if let Some(Event::Start(Tag::CodeBlock(lang))) = event {
|
||||
let parse_result = LangString::parse(&lang);
|
||||
let parse_result = LangString::parse(&lang, self.check_error_codes);
|
||||
if !parse_result.rust {
|
||||
return Some(Event::Start(Tag::CodeBlock(lang)));
|
||||
}
|
||||
|
|
@ -224,7 +247,6 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'a, I> {
|
|||
if ignore { " ignore" }
|
||||
else if compile_fail { " compile_fail" }
|
||||
else { "" })),
|
||||
None,
|
||||
playground_button.as_ref().map(String::as_str),
|
||||
tooltip));
|
||||
Some(Event::Html(s.into()))
|
||||
|
|
@ -266,23 +288,25 @@ impl<'a, 'b, I: Iterator<Item = Event<'a>>> Iterator for LinkReplacer<'a, 'b, I>
|
|||
}
|
||||
|
||||
/// Make headings links with anchor ids and build up TOC.
|
||||
struct HeadingLinks<'a, 'b, I: Iterator<Item = Event<'a>>> {
|
||||
struct HeadingLinks<'a, 'b, 'ids, I: Iterator<Item = Event<'a>>> {
|
||||
inner: I,
|
||||
toc: Option<&'b mut TocBuilder>,
|
||||
buf: VecDeque<Event<'a>>,
|
||||
id_map: &'ids mut IdMap,
|
||||
}
|
||||
|
||||
impl<'a, 'b, I: Iterator<Item = Event<'a>>> HeadingLinks<'a, 'b, I> {
|
||||
fn new(iter: I, toc: Option<&'b mut TocBuilder>) -> Self {
|
||||
impl<'a, 'b, 'ids, I: Iterator<Item = Event<'a>>> HeadingLinks<'a, 'b, 'ids, I> {
|
||||
fn new(iter: I, toc: Option<&'b mut TocBuilder>, ids: &'ids mut IdMap) -> Self {
|
||||
HeadingLinks {
|
||||
inner: iter,
|
||||
toc,
|
||||
buf: VecDeque::new(),
|
||||
id_map: ids,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b, I: Iterator<Item = Event<'a>>> Iterator for HeadingLinks<'a, 'b, I> {
|
||||
impl<'a, 'b, 'ids, I: Iterator<Item = Event<'a>>> Iterator for HeadingLinks<'a, 'b, 'ids, I> {
|
||||
type Item = Event<'a>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
|
|
@ -301,7 +325,7 @@ impl<'a, 'b, I: Iterator<Item = Event<'a>>> Iterator for HeadingLinks<'a, 'b, I>
|
|||
}
|
||||
self.buf.push_back(event);
|
||||
}
|
||||
let id = derive_id(id);
|
||||
let id = self.id_map.derive(id);
|
||||
|
||||
if let Some(ref mut builder) = self.toc {
|
||||
let mut html_header = String::new();
|
||||
|
|
@ -467,10 +491,17 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for Footnotes<'a, I> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Span,
|
||||
sess: Option<&session::Session>) {
|
||||
tests.set_position(position);
|
||||
pub struct TestableCodeError(());
|
||||
|
||||
impl fmt::Display for TestableCodeError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "invalid start of a new code block")
|
||||
}
|
||||
}
|
||||
|
||||
pub fn find_testable_code(
|
||||
doc: &str, tests: &mut test::Collector, error_codes: ErrorCodes,
|
||||
) -> Result<(), TestableCodeError> {
|
||||
let mut parser = Parser::new(doc);
|
||||
let mut prev_offset = 0;
|
||||
let mut nb_lines = 0;
|
||||
|
|
@ -481,7 +512,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Sp
|
|||
let block_info = if s.is_empty() {
|
||||
LangString::all_false()
|
||||
} else {
|
||||
LangString::parse(&*s)
|
||||
LangString::parse(&*s, error_codes)
|
||||
};
|
||||
if !block_info.rust {
|
||||
continue
|
||||
|
|
@ -510,18 +541,10 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Sp
|
|||
let text = lines.collect::<Vec<Cow<str>>>().join("\n");
|
||||
nb_lines += doc[prev_offset..offset].lines().count();
|
||||
let line = tests.get_line() + (nb_lines - 1);
|
||||
let filename = tests.get_filename();
|
||||
tests.add_test(text.to_owned(),
|
||||
block_info.should_panic, block_info.no_run,
|
||||
block_info.ignore, block_info.test_harness,
|
||||
block_info.compile_fail, block_info.error_codes,
|
||||
line, filename, block_info.allow_fail);
|
||||
tests.add_test(text, block_info, line);
|
||||
prev_offset = offset;
|
||||
} else {
|
||||
if let Some(ref sess) = sess {
|
||||
sess.span_warn(position, "invalid start of a new code block");
|
||||
}
|
||||
break;
|
||||
return Err(TestableCodeError(()));
|
||||
}
|
||||
}
|
||||
Event::Start(Tag::Header(level)) => {
|
||||
|
|
@ -539,19 +562,20 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Sp
|
|||
_ => {}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Eq, PartialEq, Clone, Debug)]
|
||||
struct LangString {
|
||||
pub struct LangString {
|
||||
original: String,
|
||||
should_panic: bool,
|
||||
no_run: bool,
|
||||
ignore: bool,
|
||||
rust: bool,
|
||||
test_harness: bool,
|
||||
compile_fail: bool,
|
||||
error_codes: Vec<String>,
|
||||
allow_fail: bool,
|
||||
pub should_panic: bool,
|
||||
pub no_run: bool,
|
||||
pub ignore: bool,
|
||||
pub rust: bool,
|
||||
pub test_harness: bool,
|
||||
pub compile_fail: bool,
|
||||
pub error_codes: Vec<String>,
|
||||
pub allow_fail: bool,
|
||||
}
|
||||
|
||||
impl LangString {
|
||||
|
|
@ -569,14 +593,11 @@ impl LangString {
|
|||
}
|
||||
}
|
||||
|
||||
fn parse(string: &str) -> LangString {
|
||||
fn parse(string: &str, allow_error_code_check: ErrorCodes) -> LangString {
|
||||
let allow_error_code_check = allow_error_code_check.as_bool();
|
||||
let mut seen_rust_tags = false;
|
||||
let mut seen_other_tags = false;
|
||||
let mut data = LangString::all_false();
|
||||
let mut allow_error_code_check = false;
|
||||
if UnstableFeatures::from_environment().is_nightly_build() {
|
||||
allow_error_code_check = true;
|
||||
}
|
||||
|
||||
data.original = string.to_owned();
|
||||
let tokens = string.split(|c: char|
|
||||
|
|
@ -623,7 +644,8 @@ impl LangString {
|
|||
|
||||
impl<'a> fmt::Display for Markdown<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
let Markdown(md, links) = *self;
|
||||
let Markdown(md, links, ref ids, codes) = *self;
|
||||
let mut ids = ids.borrow_mut();
|
||||
|
||||
// This is actually common enough to special-case
|
||||
if md.is_empty() { return Ok(()) }
|
||||
|
|
@ -643,12 +665,11 @@ impl<'a> fmt::Display for Markdown<'a> {
|
|||
|
||||
let mut s = String::with_capacity(md.len() * 3 / 2);
|
||||
|
||||
html::push_html(&mut s,
|
||||
Footnotes::new(
|
||||
CodeBlocks::new(
|
||||
LinkReplacer::new(
|
||||
HeadingLinks::new(p, None),
|
||||
links))));
|
||||
let p = HeadingLinks::new(p, None, &mut ids);
|
||||
let p = LinkReplacer::new(p, links);
|
||||
let p = CodeBlocks::new(p, codes);
|
||||
let p = Footnotes::new(p);
|
||||
html::push_html(&mut s, p);
|
||||
|
||||
fmt.write_str(&s)
|
||||
}
|
||||
|
|
@ -656,7 +677,8 @@ 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;
|
||||
let MarkdownWithToc(md, ref ids, codes) = *self;
|
||||
let mut ids = ids.borrow_mut();
|
||||
|
||||
let mut opts = Options::empty();
|
||||
opts.insert(OPTION_ENABLE_TABLES);
|
||||
|
|
@ -668,8 +690,12 @@ impl<'a> fmt::Display for MarkdownWithToc<'a> {
|
|||
|
||||
let mut toc = TocBuilder::new();
|
||||
|
||||
html::push_html(&mut s,
|
||||
Footnotes::new(CodeBlocks::new(HeadingLinks::new(p, Some(&mut toc)))));
|
||||
{
|
||||
let p = HeadingLinks::new(p, Some(&mut toc), &mut ids);
|
||||
let p = CodeBlocks::new(p, codes);
|
||||
let p = Footnotes::new(p);
|
||||
html::push_html(&mut s, p);
|
||||
}
|
||||
|
||||
write!(fmt, "<nav id=\"TOC\">{}</nav>", toc.into_toc())?;
|
||||
|
||||
|
|
@ -679,7 +705,8 @@ impl<'a> fmt::Display for MarkdownWithToc<'a> {
|
|||
|
||||
impl<'a> fmt::Display for MarkdownHtml<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
let MarkdownHtml(md) = *self;
|
||||
let MarkdownHtml(md, ref ids, codes) = *self;
|
||||
let mut ids = ids.borrow_mut();
|
||||
|
||||
// This is actually common enough to special-case
|
||||
if md.is_empty() { return Ok(()) }
|
||||
|
|
@ -697,8 +724,10 @@ impl<'a> fmt::Display for MarkdownHtml<'a> {
|
|||
|
||||
let mut s = String::with_capacity(md.len() * 3 / 2);
|
||||
|
||||
html::push_html(&mut s,
|
||||
Footnotes::new(CodeBlocks::new(HeadingLinks::new(p, None))));
|
||||
let p = HeadingLinks::new(p, None, &mut ids);
|
||||
let p = CodeBlocks::new(p, codes);
|
||||
let p = Footnotes::new(p);
|
||||
html::push_html(&mut s, p);
|
||||
|
||||
fmt.write_str(&s)
|
||||
}
|
||||
|
|
@ -812,7 +841,10 @@ pub fn markdown_links(md: &str) -> Vec<(String, Option<Range<usize>>)> {
|
|||
let p = Parser::new_with_broken_link_callback(md, opts,
|
||||
Some(&push));
|
||||
|
||||
let iter = Footnotes::new(HeadingLinks::new(p, None));
|
||||
// There's no need to thread an IdMap through to here because
|
||||
// the IDs generated aren't going to be emitted anywhere.
|
||||
let mut ids = IdMap::new();
|
||||
let iter = Footnotes::new(HeadingLinks::new(p, None, &mut ids));
|
||||
|
||||
for ev in iter {
|
||||
if let Event::Start(Tag::Link(dest, _)) = ev {
|
||||
|
|
@ -831,18 +863,74 @@ pub fn markdown_links(md: &str) -> Vec<(String, Option<Range<usize>>)> {
|
|||
links
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct IdMap {
|
||||
map: HashMap<String, usize>,
|
||||
}
|
||||
|
||||
impl IdMap {
|
||||
pub fn new() -> Self {
|
||||
IdMap::default()
|
||||
}
|
||||
|
||||
pub fn populate<I: IntoIterator<Item=String>>(&mut self, ids: I) {
|
||||
for id in ids {
|
||||
let _ = self.derive(id);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.map = HashMap::new();
|
||||
}
|
||||
|
||||
pub fn derive(&mut self, candidate: String) -> String {
|
||||
let id = match self.map.get_mut(&candidate) {
|
||||
None => candidate,
|
||||
Some(a) => {
|
||||
let id = format!("{}-{}", candidate, *a);
|
||||
*a += 1;
|
||||
id
|
||||
}
|
||||
};
|
||||
|
||||
self.map.insert(id.clone(), 1);
|
||||
id
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[test]
|
||||
fn test_unique_id() {
|
||||
let input = ["foo", "examples", "examples", "method.into_iter","examples",
|
||||
"method.into_iter", "foo", "main", "search", "methods",
|
||||
"examples", "method.into_iter", "assoc_type.Item", "assoc_type.Item"];
|
||||
let expected = ["foo", "examples", "examples-1", "method.into_iter", "examples-2",
|
||||
"method.into_iter-1", "foo-1", "main", "search", "methods",
|
||||
"examples-3", "method.into_iter-2", "assoc_type.Item", "assoc_type.Item-1"];
|
||||
|
||||
let map = RefCell::new(IdMap::new());
|
||||
let test = || {
|
||||
let mut map = map.borrow_mut();
|
||||
let actual: Vec<String> = input.iter().map(|s| map.derive(s.to_string())).collect();
|
||||
assert_eq!(&actual[..], expected);
|
||||
};
|
||||
test();
|
||||
map.borrow_mut().reset();
|
||||
test();
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{LangString, Markdown, MarkdownHtml};
|
||||
use super::{ErrorCodes, LangString, Markdown, MarkdownHtml, IdMap};
|
||||
use super::plain_summary_line;
|
||||
use html::render::reset_ids;
|
||||
use std::cell::RefCell;
|
||||
|
||||
#[test]
|
||||
fn test_lang_string_parse() {
|
||||
fn t(s: &str,
|
||||
should_panic: bool, no_run: bool, ignore: bool, rust: bool, test_harness: bool,
|
||||
compile_fail: bool, allow_fail: bool, error_codes: Vec<String>) {
|
||||
assert_eq!(LangString::parse(s), LangString {
|
||||
assert_eq!(LangString::parse(s, ErrorCodes::Yes), LangString {
|
||||
should_panic,
|
||||
no_run,
|
||||
ignore,
|
||||
|
|
@ -878,19 +966,12 @@ mod tests {
|
|||
t("text,no_run", false, true, false, false, false, false, false, v());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn issue_17736() {
|
||||
let markdown = "# title";
|
||||
Markdown(markdown, &[]).to_string();
|
||||
reset_ids(true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_header() {
|
||||
fn t(input: &str, expect: &str) {
|
||||
let output = Markdown(input, &[]).to_string();
|
||||
let mut map = IdMap::new();
|
||||
let output = Markdown(input, &[], RefCell::new(&mut map), ErrorCodes::Yes).to_string();
|
||||
assert_eq!(output, expect, "original: {}", input);
|
||||
reset_ids(true);
|
||||
}
|
||||
|
||||
t("# Foo bar", "<h1 id=\"foo-bar\" class=\"section-header\">\
|
||||
|
|
@ -909,28 +990,24 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_header_ids_multiple_blocks() {
|
||||
fn t(input: &str, expect: &str) {
|
||||
let output = Markdown(input, &[]).to_string();
|
||||
let mut map = IdMap::new();
|
||||
fn t(map: &mut IdMap, input: &str, expect: &str) {
|
||||
let output = Markdown(input, &[], RefCell::new(map), ErrorCodes::Yes).to_string();
|
||||
assert_eq!(output, expect, "original: {}", input);
|
||||
}
|
||||
|
||||
let test = || {
|
||||
t("# Example", "<h1 id=\"example\" class=\"section-header\">\
|
||||
<a href=\"#example\">Example</a></h1>");
|
||||
t("# Panics", "<h1 id=\"panics\" class=\"section-header\">\
|
||||
<a href=\"#panics\">Panics</a></h1>");
|
||||
t("# Example", "<h1 id=\"example-1\" class=\"section-header\">\
|
||||
<a href=\"#example-1\">Example</a></h1>");
|
||||
t("# Main", "<h1 id=\"main-1\" class=\"section-header\">\
|
||||
<a href=\"#main-1\">Main</a></h1>");
|
||||
t("# Example", "<h1 id=\"example-2\" class=\"section-header\">\
|
||||
<a href=\"#example-2\">Example</a></h1>");
|
||||
t("# Panics", "<h1 id=\"panics-1\" class=\"section-header\">\
|
||||
<a href=\"#panics-1\">Panics</a></h1>");
|
||||
};
|
||||
test();
|
||||
reset_ids(true);
|
||||
test();
|
||||
t(&mut map, "# Example", "<h1 id=\"example\" class=\"section-header\">\
|
||||
<a href=\"#example\">Example</a></h1>");
|
||||
t(&mut map, "# Panics", "<h1 id=\"panics\" class=\"section-header\">\
|
||||
<a href=\"#panics\">Panics</a></h1>");
|
||||
t(&mut map, "# Example", "<h1 id=\"example-1\" class=\"section-header\">\
|
||||
<a href=\"#example-1\">Example</a></h1>");
|
||||
t(&mut map, "# Main", "<h1 id=\"main\" class=\"section-header\">\
|
||||
<a href=\"#main\">Main</a></h1>");
|
||||
t(&mut map, "# Example", "<h1 id=\"example-2\" class=\"section-header\">\
|
||||
<a href=\"#example-2\">Example</a></h1>");
|
||||
t(&mut map, "# Panics", "<h1 id=\"panics-1\" class=\"section-header\">\
|
||||
<a href=\"#panics-1\">Panics</a></h1>");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -951,7 +1028,8 @@ mod tests {
|
|||
#[test]
|
||||
fn test_markdown_html_escape() {
|
||||
fn t(input: &str, expect: &str) {
|
||||
let output = MarkdownHtml(input).to_string();
|
||||
let mut idmap = IdMap::new();
|
||||
let output = MarkdownHtml(input, RefCell::new(&mut idmap), ErrorCodes::Yes).to_string();
|
||||
assert_eq!(output, expect, "original: {}", input);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -50,12 +50,14 @@ use std::mem;
|
|||
use std::path::{PathBuf, Path, Component};
|
||||
use std::str;
|
||||
use std::sync::Arc;
|
||||
use std::rc::Rc;
|
||||
|
||||
use externalfiles::ExternalHtml;
|
||||
|
||||
use serialize::json::{ToJson, Json, as_json};
|
||||
use syntax::ast;
|
||||
use syntax::codemap::FileName;
|
||||
use syntax::feature_gate::UnstableFeatures;
|
||||
use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId};
|
||||
use rustc::middle::privacy::AccessLevels;
|
||||
use rustc::middle::stability;
|
||||
|
|
@ -72,7 +74,7 @@ use html::format::{GenericBounds, 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, MarkdownSummaryLine};
|
||||
use html::markdown::{self, Markdown, MarkdownHtml, MarkdownSummaryLine, ErrorCodes, IdMap};
|
||||
use html::{highlight, layout};
|
||||
|
||||
use minifier;
|
||||
|
|
@ -88,7 +90,7 @@ pub type NameDoc = (String, Option<String>);
|
|||
/// easily cloned because it is cloned per work-job (about once per item in the
|
||||
/// rustdoc tree).
|
||||
#[derive(Clone)]
|
||||
pub struct Context {
|
||||
struct Context {
|
||||
/// Current hierarchy of components leading down to what's currently being
|
||||
/// rendered
|
||||
pub current: Vec<String>,
|
||||
|
|
@ -99,10 +101,13 @@ pub struct Context {
|
|||
/// real location of an item. This is used to allow external links to
|
||||
/// publicly reused items to redirect to the right location.
|
||||
pub render_redirect_pages: bool,
|
||||
pub codes: ErrorCodes,
|
||||
/// The map used to ensure all generated 'id=' attributes are unique.
|
||||
id_map: Rc<RefCell<IdMap>>,
|
||||
pub shared: Arc<SharedContext>,
|
||||
}
|
||||
|
||||
pub struct SharedContext {
|
||||
struct SharedContext {
|
||||
/// The path to the crate root source minus the file name.
|
||||
/// Used for simplifying paths to the highlighted source code files.
|
||||
pub src_root: PathBuf,
|
||||
|
|
@ -450,9 +455,8 @@ impl ToJson for IndexItemFunctionType {
|
|||
|
||||
thread_local!(static CACHE_KEY: RefCell<Arc<Cache>> = Default::default());
|
||||
thread_local!(pub static CURRENT_LOCATION_KEY: RefCell<Vec<String>> = RefCell::new(Vec::new()));
|
||||
thread_local!(pub static USED_ID_MAP: RefCell<FxHashMap<String, usize>> = RefCell::new(init_ids()));
|
||||
|
||||
fn init_ids() -> FxHashMap<String, usize> {
|
||||
pub fn initial_ids() -> Vec<String> {
|
||||
[
|
||||
"main",
|
||||
"search",
|
||||
|
|
@ -470,36 +474,7 @@ fn init_ids() -> FxHashMap<String, usize> {
|
|||
"methods",
|
||||
"deref-methods",
|
||||
"implementations",
|
||||
].into_iter().map(|id| (String::from(*id), 1)).collect()
|
||||
}
|
||||
|
||||
/// This method resets the local table of used ID attributes. This is typically
|
||||
/// used at the beginning of rendering an entire HTML page to reset from the
|
||||
/// previous state (if any).
|
||||
pub fn reset_ids(embedded: bool) {
|
||||
USED_ID_MAP.with(|s| {
|
||||
*s.borrow_mut() = if embedded {
|
||||
init_ids()
|
||||
} else {
|
||||
FxHashMap()
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
pub fn derive_id(candidate: String) -> String {
|
||||
USED_ID_MAP.with(|map| {
|
||||
let id = match map.borrow_mut().get_mut(&candidate) {
|
||||
None => candidate,
|
||||
Some(a) => {
|
||||
let id = format!("{}-{}", candidate, *a);
|
||||
*a += 1;
|
||||
id
|
||||
}
|
||||
};
|
||||
|
||||
map.borrow_mut().insert(id.clone(), 1);
|
||||
id
|
||||
})
|
||||
].into_iter().map(|id| (String::from(*id))).collect()
|
||||
}
|
||||
|
||||
/// Generates the documentation for `crate` into the directory `dst`
|
||||
|
|
@ -513,7 +488,8 @@ pub fn run(mut krate: clean::Crate,
|
|||
renderinfo: RenderInfo,
|
||||
sort_modules_alphabetically: bool,
|
||||
themes: Vec<PathBuf>,
|
||||
enable_minification: bool) -> Result<(), Error> {
|
||||
enable_minification: bool,
|
||||
id_map: IdMap) -> Result<(), Error> {
|
||||
let src_root = match krate.src {
|
||||
FileName::Real(ref p) => match p.parent() {
|
||||
Some(p) => p.to_path_buf(),
|
||||
|
|
@ -581,6 +557,8 @@ pub fn run(mut krate: clean::Crate,
|
|||
current: Vec::new(),
|
||||
dst,
|
||||
render_redirect_pages: false,
|
||||
codes: ErrorCodes::from(UnstableFeatures::from_environment().is_nightly_build()),
|
||||
id_map: Rc::new(RefCell::new(id_map)),
|
||||
shared: Arc::new(scx),
|
||||
};
|
||||
|
||||
|
|
@ -1708,6 +1686,11 @@ impl<'a> fmt::Display for Settings<'a> {
|
|||
}
|
||||
|
||||
impl Context {
|
||||
fn derive_id(&self, id: String) -> String {
|
||||
let mut map = self.id_map.borrow_mut();
|
||||
map.derive(id)
|
||||
}
|
||||
|
||||
/// String representation of how to get back to the root path of the 'doc/'
|
||||
/// folder in terms of a relative URL.
|
||||
fn root_path(&self) -> String {
|
||||
|
|
@ -1862,7 +1845,10 @@ impl Context {
|
|||
resource_suffix: &self.shared.resource_suffix,
|
||||
};
|
||||
|
||||
reset_ids(true);
|
||||
{
|
||||
self.id_map.borrow_mut().reset();
|
||||
self.id_map.borrow_mut().populate(initial_ids());
|
||||
}
|
||||
|
||||
if !self.render_redirect_pages {
|
||||
layout::render(writer, &self.shared.layout, &page,
|
||||
|
|
@ -2219,14 +2205,17 @@ fn document(w: &mut fmt::Formatter, cx: &Context, item: &clean::Item) -> fmt::Re
|
|||
|
||||
/// Render md_text as markdown.
|
||||
fn render_markdown(w: &mut fmt::Formatter,
|
||||
cx: &Context,
|
||||
md_text: &str,
|
||||
links: Vec<(String, String)>,
|
||||
prefix: &str,)
|
||||
prefix: &str)
|
||||
-> fmt::Result {
|
||||
write!(w, "<div class='docblock'>{}{}</div>", prefix, Markdown(md_text, &links))
|
||||
let mut ids = cx.id_map.borrow_mut();
|
||||
write!(w, "<div class='docblock'>{}{}</div>",
|
||||
prefix, Markdown(md_text, &links, RefCell::new(&mut ids), cx.codes))
|
||||
}
|
||||
|
||||
fn document_short(w: &mut fmt::Formatter, item: &clean::Item, link: AssocItemLink,
|
||||
fn document_short(w: &mut fmt::Formatter, cx: &Context, item: &clean::Item, link: AssocItemLink,
|
||||
prefix: &str) -> fmt::Result {
|
||||
if let Some(s) = item.doc_value() {
|
||||
let markdown = if s.contains('\n') {
|
||||
|
|
@ -2235,7 +2224,7 @@ fn document_short(w: &mut fmt::Formatter, item: &clean::Item, link: AssocItemLin
|
|||
} else {
|
||||
plain_summary_line(Some(s)).to_string()
|
||||
};
|
||||
render_markdown(w, &markdown, item.links(), prefix)?;
|
||||
render_markdown(w, cx, &markdown, item.links(), prefix)?;
|
||||
} else if !prefix.is_empty() {
|
||||
write!(w, "<div class='docblock'>{}</div>", prefix)?;
|
||||
}
|
||||
|
|
@ -2250,7 +2239,6 @@ fn render_assoc_const_value(item: &clean::Item) -> String {
|
|||
None,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
}
|
||||
_ => String::new(),
|
||||
|
|
@ -2261,7 +2249,7 @@ fn document_full(w: &mut fmt::Formatter, item: &clean::Item,
|
|||
cx: &Context, prefix: &str) -> fmt::Result {
|
||||
if let Some(s) = cx.shared.maybe_collapsed_doc_value(item) {
|
||||
debug!("Doc block: =====\n{}\n=====", s);
|
||||
render_markdown(w, &*s, item.links(), prefix)?;
|
||||
render_markdown(w, cx, &*s, item.links(), prefix)?;
|
||||
} else if !prefix.is_empty() {
|
||||
write!(w, "<div class='docblock'>{}</div>", prefix)?;
|
||||
}
|
||||
|
|
@ -2427,7 +2415,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
|
|||
let (short, name) = item_ty_to_strs(&myty.unwrap());
|
||||
write!(w, "<h2 id='{id}' class='section-header'>\
|
||||
<a href=\"#{id}\">{name}</a></h2>\n<table>",
|
||||
id = derive_id(short.to_owned()), name = name)?;
|
||||
id = cx.derive_id(short.to_owned()), name = name)?;
|
||||
}
|
||||
|
||||
match myitem.inner {
|
||||
|
|
@ -2508,6 +2496,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
|
|||
|
||||
fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Vec<String> {
|
||||
let mut stability = vec![];
|
||||
let error_codes = ErrorCodes::from(UnstableFeatures::from_environment().is_nightly_build());
|
||||
|
||||
if let Some(stab) = item.stability.as_ref() {
|
||||
let deprecated_reason = if show_reason && !stab.deprecated_reason.is_empty() {
|
||||
|
|
@ -2521,14 +2510,12 @@ fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Vec<S
|
|||
} else {
|
||||
String::new()
|
||||
};
|
||||
let mut ids = cx.id_map.borrow_mut();
|
||||
let html = MarkdownHtml(&deprecated_reason, RefCell::new(&mut ids), error_codes);
|
||||
let text = if stability::deprecation_in_effect(&stab.deprecated_since) {
|
||||
format!("Deprecated{}{}",
|
||||
since,
|
||||
MarkdownHtml(&deprecated_reason))
|
||||
format!("Deprecated{}{}", since, html)
|
||||
} else {
|
||||
format!("Deprecating in {}{}",
|
||||
Escape(&stab.deprecated_since),
|
||||
MarkdownHtml(&deprecated_reason))
|
||||
format!("Deprecating in {}{}", Escape(&stab.deprecated_since), html)
|
||||
};
|
||||
stability.push(format!("<div class='stab deprecated'>{}</div>", text))
|
||||
};
|
||||
|
|
@ -2555,11 +2542,15 @@ fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Vec<S
|
|||
</div>",
|
||||
unstable_extra));
|
||||
} else {
|
||||
let mut ids = cx.id_map.borrow_mut();
|
||||
let text = format!("<summary><span class=microscope>🔬</span> \
|
||||
This is a nightly-only experimental API. {}\
|
||||
</summary>{}",
|
||||
unstable_extra,
|
||||
MarkdownHtml(&stab.unstable_reason));
|
||||
MarkdownHtml(
|
||||
&stab.unstable_reason,
|
||||
RefCell::new(&mut ids),
|
||||
error_codes));
|
||||
stability.push(format!("<div class='stab unstable'><details>{}</details></div>",
|
||||
text));
|
||||
}
|
||||
|
|
@ -2579,14 +2570,15 @@ fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Vec<S
|
|||
String::new()
|
||||
};
|
||||
|
||||
let mut ids = cx.id_map.borrow_mut();
|
||||
let text = if stability::deprecation_in_effect(&depr.since) {
|
||||
format!("Deprecated{}{}",
|
||||
since,
|
||||
MarkdownHtml(¬e))
|
||||
MarkdownHtml(¬e, RefCell::new(&mut ids), error_codes))
|
||||
} else {
|
||||
format!("Deprecating in {}{}",
|
||||
Escape(&depr.since),
|
||||
MarkdownHtml(¬e))
|
||||
MarkdownHtml(¬e, RefCell::new(&mut ids), error_codes))
|
||||
};
|
||||
stability.push(format!("<div class='stab deprecated'>{}</div>", text))
|
||||
}
|
||||
|
|
@ -2827,8 +2819,8 @@ fn item_trait(
|
|||
-> fmt::Result {
|
||||
let name = m.name.as_ref().unwrap();
|
||||
let item_type = m.type_();
|
||||
let id = derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
let id = cx.derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
write!(w, "{extra}<h3 id='{id}' class='method'>\
|
||||
<span id='{ns_id}' class='invisible'><code>",
|
||||
extra = render_spotlight_traits(m)?,
|
||||
|
|
@ -3183,10 +3175,10 @@ fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
|
|||
document_non_exhaustive_header(it))?;
|
||||
document_non_exhaustive(w, it)?;
|
||||
for (field, ty) in fields {
|
||||
let id = derive_id(format!("{}.{}",
|
||||
let id = cx.derive_id(format!("{}.{}",
|
||||
ItemType::StructField,
|
||||
field.name.as_ref().unwrap()));
|
||||
let ns_id = derive_id(format!("{}.{}",
|
||||
let ns_id = cx.derive_id(format!("{}.{}",
|
||||
field.name.as_ref().unwrap(),
|
||||
ItemType::StructField.name_space()));
|
||||
write!(w, "<span id=\"{id}\" class=\"{item_type} small-section-header\">
|
||||
|
|
@ -3317,10 +3309,10 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
|
|||
document_non_exhaustive_header(it))?;
|
||||
document_non_exhaustive(w, it)?;
|
||||
for variant in &e.variants {
|
||||
let id = derive_id(format!("{}.{}",
|
||||
let id = cx.derive_id(format!("{}.{}",
|
||||
ItemType::Variant,
|
||||
variant.name.as_ref().unwrap()));
|
||||
let ns_id = derive_id(format!("{}.{}",
|
||||
let ns_id = cx.derive_id(format!("{}.{}",
|
||||
variant.name.as_ref().unwrap(),
|
||||
ItemType::Variant.name_space()));
|
||||
write!(w, "<span id=\"{id}\" class=\"variant small-section-header\">\
|
||||
|
|
@ -3348,7 +3340,7 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
|
|||
if let clean::VariantItem(Variant {
|
||||
kind: VariantKind::Struct(ref s)
|
||||
}) = variant.inner {
|
||||
let variant_id = derive_id(format!("{}.{}.fields",
|
||||
let variant_id = cx.derive_id(format!("{}.{}.fields",
|
||||
ItemType::Variant,
|
||||
variant.name.as_ref().unwrap()));
|
||||
write!(w, "<span class='docblock autohide sub-variant' id='{id}'>",
|
||||
|
|
@ -3358,10 +3350,10 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
|
|||
for field in &s.fields {
|
||||
use clean::StructFieldItem;
|
||||
if let StructFieldItem(ref ty) = field.inner {
|
||||
let id = derive_id(format!("variant.{}.field.{}",
|
||||
let id = cx.derive_id(format!("variant.{}.field.{}",
|
||||
variant.name.as_ref().unwrap(),
|
||||
field.name.as_ref().unwrap()));
|
||||
let ns_id = derive_id(format!("{}.{}.{}.{}",
|
||||
let ns_id = cx.derive_id(format!("{}.{}.{}.{}",
|
||||
variant.name.as_ref().unwrap(),
|
||||
ItemType::Variant.name_space(),
|
||||
field.name.as_ref().unwrap(),
|
||||
|
|
@ -3790,7 +3782,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
|
|||
render_mode: RenderMode, outer_version: Option<&str>,
|
||||
show_def_docs: bool) -> fmt::Result {
|
||||
if render_mode == RenderMode::Normal {
|
||||
let id = derive_id(match i.inner_impl().trait_ {
|
||||
let id = cx.derive_id(match i.inner_impl().trait_ {
|
||||
Some(ref t) => format!("impl-{}", small_url_encode(&format!("{:#}", t))),
|
||||
None => "impl".to_string(),
|
||||
});
|
||||
|
|
@ -3810,8 +3802,9 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
|
|||
}
|
||||
write!(w, "</span></td></tr></tbody></table></h3>")?;
|
||||
if let Some(ref dox) = cx.shared.maybe_collapsed_doc_value(&i.impl_item) {
|
||||
let mut ids = cx.id_map.borrow_mut();
|
||||
write!(w, "<div class='docblock'>{}</div>",
|
||||
Markdown(&*dox, &i.impl_item.links()))?;
|
||||
Markdown(&*dox, &i.impl_item.links(), RefCell::new(&mut ids), cx.codes))?;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3832,8 +3825,8 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
|
|||
clean::TyMethodItem(clean::TyMethod{ ref decl, .. }) => {
|
||||
// Only render when the method is not static or we allow static methods
|
||||
if render_method_item {
|
||||
let id = derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
let id = cx.derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
|
||||
write!(w, "{}", spotlight_decl(decl)?)?;
|
||||
write!(w, "<span id='{}' class='invisible'>", ns_id)?;
|
||||
|
|
@ -3854,24 +3847,24 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
|
|||
}
|
||||
}
|
||||
clean::TypedefItem(ref tydef, _) => {
|
||||
let id = derive_id(format!("{}.{}", ItemType::AssociatedType, name));
|
||||
let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
let id = cx.derive_id(format!("{}.{}", ItemType::AssociatedType, name));
|
||||
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
|
||||
write!(w, "<span id='{}' class='invisible'><code>", ns_id)?;
|
||||
assoc_type(w, item, &Vec::new(), Some(&tydef.type_), link.anchor(&id))?;
|
||||
write!(w, "</code></span></h4>\n")?;
|
||||
}
|
||||
clean::AssociatedConstItem(ref ty, ref default) => {
|
||||
let id = derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
let id = cx.derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
|
||||
write!(w, "<span id='{}' class='invisible'><code>", ns_id)?;
|
||||
assoc_const(w, item, ty, default.as_ref(), link.anchor(&id))?;
|
||||
write!(w, "</code></span></h4>\n")?;
|
||||
}
|
||||
clean::AssociatedTypeItem(ref bounds, ref default) => {
|
||||
let id = derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
let id = cx.derive_id(format!("{}.{}", item_type, name));
|
||||
let ns_id = cx.derive_id(format!("{}.{}", name, item_type.name_space()));
|
||||
write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
|
||||
write!(w, "<span id='{}' class='invisible'><code>", ns_id)?;
|
||||
assoc_type(w, item, bounds, default.as_ref(), link.anchor(&id))?;
|
||||
|
|
@ -3897,7 +3890,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
|
|||
} else if show_def_docs {
|
||||
// In case the item isn't documented,
|
||||
// provide short documentation from the trait.
|
||||
document_short(w, it, link, &prefix)?;
|
||||
document_short(w, cx, it, link, &prefix)?;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
|
@ -3909,7 +3902,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
|
|||
} else {
|
||||
document_stability(w, cx, item)?;
|
||||
if show_def_docs {
|
||||
document_short(w, item, link, &prefix)?;
|
||||
document_short(w, cx, item, link, &prefix)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -4557,7 +4550,7 @@ impl<'a> fmt::Display for Source<'a> {
|
|||
}
|
||||
write!(fmt, "</pre>")?;
|
||||
write!(fmt, "{}",
|
||||
highlight::render_with_highlighting(s, None, None, None, None))?;
|
||||
highlight::render_with_highlighting(s, None, None, None))?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
@ -4568,7 +4561,6 @@ fn item_macro(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
|
|||
w.write_str(&highlight::render_with_highlighting(&t.source,
|
||||
Some("macro"),
|
||||
None,
|
||||
None,
|
||||
None))
|
||||
})?;
|
||||
document(w, cx, it)
|
||||
|
|
@ -4715,25 +4707,6 @@ pub fn cache() -> Arc<Cache> {
|
|||
CACHE_KEY.with(|c| c.borrow().clone())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[test]
|
||||
fn test_unique_id() {
|
||||
let input = ["foo", "examples", "examples", "method.into_iter","examples",
|
||||
"method.into_iter", "foo", "main", "search", "methods",
|
||||
"examples", "method.into_iter", "assoc_type.Item", "assoc_type.Item"];
|
||||
let expected = ["foo", "examples", "examples-1", "method.into_iter", "examples-2",
|
||||
"method.into_iter-1", "foo-1", "main-1", "search-1", "methods-1",
|
||||
"examples-3", "method.into_iter-2", "assoc_type.Item", "assoc_type.Item-1"];
|
||||
|
||||
let test = || {
|
||||
let actual: Vec<String> = input.iter().map(|s| derive_id(s.to_string())).collect();
|
||||
assert_eq!(&actual[..], expected);
|
||||
};
|
||||
test();
|
||||
reset_ids(true);
|
||||
test();
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[test]
|
||||
fn test_name_key() {
|
||||
|
|
|
|||
|
|
@ -500,12 +500,14 @@ fn main_args(args: &[String]) -> isize {
|
|||
}
|
||||
}
|
||||
|
||||
let mut id_map = html::markdown::IdMap::new();
|
||||
id_map.populate(html::render::initial_ids());
|
||||
let external_html = match ExternalHtml::load(
|
||||
&matches.opt_strs("html-in-header"),
|
||||
&matches.opt_strs("html-before-content"),
|
||||
&matches.opt_strs("html-after-content"),
|
||||
&matches.opt_strs("markdown-before-content"),
|
||||
&matches.opt_strs("markdown-after-content"), &diag) {
|
||||
&matches.opt_strs("markdown-after-content"), &diag, &mut id_map) {
|
||||
Some(eh) => eh,
|
||||
None => return 3,
|
||||
};
|
||||
|
|
@ -562,7 +564,7 @@ fn main_args(args: &[String]) -> isize {
|
|||
renderinfo,
|
||||
sort_modules_alphabetically,
|
||||
themes,
|
||||
enable_minification)
|
||||
enable_minification, id_map)
|
||||
.expect("failed to generate documentation");
|
||||
0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ use std::default::Default;
|
|||
use std::fs::File;
|
||||
use std::io::prelude::*;
|
||||
use std::path::{PathBuf, Path};
|
||||
use std::cell::RefCell;
|
||||
|
||||
use errors;
|
||||
use getopts;
|
||||
|
|
@ -19,14 +20,14 @@ use testing;
|
|||
use rustc::session::search_paths::SearchPaths;
|
||||
use rustc::session::config::{Externs, CodegenOptions};
|
||||
use syntax::codemap::DUMMY_SP;
|
||||
use syntax::feature_gate::UnstableFeatures;
|
||||
use syntax::edition::Edition;
|
||||
|
||||
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::{ErrorCodes, IdMap, Markdown, MarkdownWithToc, find_testable_code};
|
||||
use test::{TestOptions, Collector};
|
||||
|
||||
/// Separate any lines at the start of the file that begin with `# ` or `%`.
|
||||
|
|
@ -86,12 +87,12 @@ pub fn render(input: &Path, mut output: PathBuf, matches: &getopts::Matches,
|
|||
}
|
||||
let title = metadata[0];
|
||||
|
||||
reset_ids(false);
|
||||
|
||||
let mut ids = IdMap::new();
|
||||
let error_codes = ErrorCodes::from(UnstableFeatures::from_environment().is_nightly_build());
|
||||
let text = if include_toc {
|
||||
MarkdownWithToc(text).to_string()
|
||||
MarkdownWithToc(text, RefCell::new(&mut ids), error_codes).to_string()
|
||||
} else {
|
||||
Markdown(text, &[]).to_string()
|
||||
Markdown(text, &[], RefCell::new(&mut ids), error_codes).to_string()
|
||||
};
|
||||
|
||||
let err = write!(
|
||||
|
|
@ -156,7 +157,12 @@ pub fn test(input: &str, cfgs: Vec<String>, libs: SearchPaths, externs: Externs,
|
|||
true, opts, maybe_sysroot, None,
|
||||
Some(PathBuf::from(input)),
|
||||
linker, edition);
|
||||
find_testable_code(&input_str, &mut collector, DUMMY_SP, None);
|
||||
collector.set_position(DUMMY_SP);
|
||||
let codes = ErrorCodes::from(UnstableFeatures::from_environment().is_nightly_build());
|
||||
let res = find_testable_code(&input_str, &mut collector, codes);
|
||||
if let Err(err) = res {
|
||||
diag.span_warn(DUMMY_SP, &err.to_string());
|
||||
}
|
||||
test_args.insert(0, "rustdoctest".to_string());
|
||||
testing::test_main(&test_args, collector.tests,
|
||||
testing::Options::new().display_output(display_warnings));
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ use errors;
|
|||
use errors::emitter::ColorConfig;
|
||||
|
||||
use clean::Attributes;
|
||||
use html::markdown;
|
||||
use html::markdown::{self, ErrorCodes, LangString};
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
pub struct TestOptions {
|
||||
|
|
@ -145,7 +145,8 @@ pub fn run(input_path: &Path,
|
|||
let mut hir_collector = HirCollector {
|
||||
sess: &sess,
|
||||
collector: &mut collector,
|
||||
map: &map
|
||||
map: &map,
|
||||
codes: ErrorCodes::from(sess.opts.unstable_features.is_nightly_build()),
|
||||
};
|
||||
hir_collector.visit_testable("".to_string(), &krate.attrs, |this| {
|
||||
intravisit::walk_crate(this, krate);
|
||||
|
|
@ -533,10 +534,8 @@ impl Collector {
|
|||
format!("{} - {} (line {})", filename, self.names.join("::"), line)
|
||||
}
|
||||
|
||||
pub fn add_test(&mut self, test: String,
|
||||
should_panic: bool, no_run: bool, should_ignore: bool,
|
||||
as_test_harness: bool, compile_fail: bool, error_codes: Vec<String>,
|
||||
line: usize, filename: FileName, allow_fail: bool) {
|
||||
pub fn add_test(&mut self, test: String, config: LangString, line: usize) {
|
||||
let filename = self.get_filename();
|
||||
let name = self.generate_name(line, &filename);
|
||||
let cfgs = self.cfgs.clone();
|
||||
let libs = self.libs.clone();
|
||||
|
|
@ -551,10 +550,10 @@ impl Collector {
|
|||
self.tests.push(testing::TestDescAndFn {
|
||||
desc: testing::TestDesc {
|
||||
name: testing::DynTestName(name.clone()),
|
||||
ignore: should_ignore,
|
||||
ignore: config.ignore,
|
||||
// compiler failures are test failures
|
||||
should_panic: testing::ShouldPanic::No,
|
||||
allow_fail,
|
||||
allow_fail: config.allow_fail,
|
||||
},
|
||||
testfn: testing::DynTestFn(box move || {
|
||||
let panic = io::set_panic(None);
|
||||
|
|
@ -572,11 +571,11 @@ impl Collector {
|
|||
libs,
|
||||
cg,
|
||||
externs,
|
||||
should_panic,
|
||||
no_run,
|
||||
as_test_harness,
|
||||
compile_fail,
|
||||
error_codes,
|
||||
config.should_panic,
|
||||
config.no_run,
|
||||
config.test_harness,
|
||||
config.compile_fail,
|
||||
config.error_codes,
|
||||
&opts,
|
||||
maybe_sysroot,
|
||||
linker,
|
||||
|
|
@ -604,7 +603,7 @@ impl Collector {
|
|||
self.position = position;
|
||||
}
|
||||
|
||||
pub fn get_filename(&self) -> FileName {
|
||||
fn get_filename(&self) -> FileName {
|
||||
if let Some(ref codemap) = self.codemap {
|
||||
let filename = codemap.span_to_filename(self.position);
|
||||
if let FileName::Real(ref filename) = filename {
|
||||
|
|
@ -664,7 +663,8 @@ impl Collector {
|
|||
struct HirCollector<'a, 'hir: 'a> {
|
||||
sess: &'a session::Session,
|
||||
collector: &'a mut Collector,
|
||||
map: &'a hir::map::Map<'hir>
|
||||
map: &'a hir::map::Map<'hir>,
|
||||
codes: ErrorCodes,
|
||||
}
|
||||
|
||||
impl<'a, 'hir> HirCollector<'a, 'hir> {
|
||||
|
|
@ -689,10 +689,12 @@ impl<'a, 'hir> HirCollector<'a, 'hir> {
|
|||
// the collapse-docs pass won't combine sugared/raw doc attributes, or included files with
|
||||
// anything else, this will combine them for us
|
||||
if let Some(doc) = attrs.collapsed_doc_value() {
|
||||
markdown::find_testable_code(&doc,
|
||||
self.collector,
|
||||
attrs.span.unwrap_or(DUMMY_SP),
|
||||
Some(self.sess));
|
||||
self.collector.set_position(attrs.span.unwrap_or(DUMMY_SP));
|
||||
let res = markdown::find_testable_code(&doc, self.collector, self.codes);
|
||||
if let Err(err) = res {
|
||||
self.sess.diagnostic().span_warn(attrs.span.unwrap_or(DUMMY_SP),
|
||||
&err.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
nested(self);
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ error[E0425]: cannot find value `no` in this scope
|
|||
3 | no
|
||||
| ^^ not found in this scope
|
||||
|
||||
thread '$DIR/failed-doctest-output.rs - OtherStruct (line 26)' panicked at 'couldn't compile the test', librustdoc/test.rs:332:13
|
||||
thread '$DIR/failed-doctest-output.rs - OtherStruct (line 26)' panicked at 'couldn't compile the test', librustdoc/test.rs:333:13
|
||||
note: Run with `RUST_BACKTRACE=1` for a backtrace.
|
||||
|
||||
---- $DIR/failed-doctest-output.rs - SomeStruct (line 20) stdout ----
|
||||
|
|
@ -21,7 +21,7 @@ thread '$DIR/failed-doctest-output.rs - SomeStruct (line 20)' panicked at 'test
|
|||
thread 'main' panicked at 'oh no', $DIR/failed-doctest-output.rs:3:1
|
||||
note: Run with `RUST_BACKTRACE=1` for a backtrace.
|
||||
|
||||
', librustdoc/test.rs:367:17
|
||||
', librustdoc/test.rs:368:17
|
||||
|
||||
|
||||
failures:
|
||||
|
|
|
|||
|
|
@ -21,10 +21,11 @@ use std::fs::{read_dir, File};
|
|||
use std::io::{Read, Write};
|
||||
use std::path::Path;
|
||||
use std::path::PathBuf;
|
||||
use std::cell::RefCell;
|
||||
|
||||
use syntax::diagnostics::metadata::{get_metadata_dir, ErrorMetadataMap, ErrorMetadata};
|
||||
|
||||
use rustdoc::html::markdown::{Markdown, PLAYGROUND};
|
||||
use rustdoc::html::markdown::{Markdown, IdMap, ErrorCodes, PLAYGROUND};
|
||||
use rustc_serialize::json;
|
||||
|
||||
enum OutputFormat {
|
||||
|
|
@ -36,7 +37,7 @@ enum OutputFormat {
|
|||
impl OutputFormat {
|
||||
fn from(format: &str) -> OutputFormat {
|
||||
match &*format.to_lowercase() {
|
||||
"html" => OutputFormat::HTML(HTMLFormatter),
|
||||
"html" => OutputFormat::HTML(HTMLFormatter(RefCell::new(IdMap::new()))),
|
||||
"markdown" => OutputFormat::Markdown(MarkdownFormatter),
|
||||
s => OutputFormat::Unknown(s.to_owned()),
|
||||
}
|
||||
|
|
@ -51,7 +52,7 @@ trait Formatter {
|
|||
fn footer(&self, output: &mut dyn Write) -> Result<(), Box<dyn Error>>;
|
||||
}
|
||||
|
||||
struct HTMLFormatter;
|
||||
struct HTMLFormatter(RefCell<IdMap>);
|
||||
struct MarkdownFormatter;
|
||||
|
||||
impl Formatter for HTMLFormatter {
|
||||
|
|
@ -100,7 +101,11 @@ impl Formatter for HTMLFormatter {
|
|||
|
||||
// Description rendered as markdown.
|
||||
match info.description {
|
||||
Some(ref desc) => write!(output, "{}", Markdown(desc, &[]))?,
|
||||
Some(ref desc) => {
|
||||
let mut id_map = self.0.borrow_mut();
|
||||
write!(output, "{}",
|
||||
Markdown(desc, &[], RefCell::new(&mut id_map), ErrorCodes::Yes))?
|
||||
},
|
||||
None => write!(output, "<p>No description.</p>\n")?,
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue