bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Hide type declarations by default

Browse source
This commit is contained in:
Guillaume Gomez 2018-03-27 11:57:00 +02:00
parent 184156ed97
commit 73b97c7e7c
2 changed files with 166 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1675,11 +1675,19 @@ impl<'a> Item<'a> {
} }
} }
fn wrap_into_docblock<F>(w: &mut fmt::Formatter,
f: F) -> fmt::Result
where F: Fn(&mut fmt::Formatter) -> fmt::Result {
write!(w, "<div class=\"docblock type-decl\">")?;
f(w)?;
write!(w, "</div>")
}
impl<'a> fmt::Display for Item<'a> { impl<'a> fmt::Display for Item<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
debug_assert!(!self.item.is_stripped()); debug_assert!(!self.item.is_stripped());
// Write the breadcrumb trail header for the top // Write the breadcrumb trail header for the top
write!(fmt, "\n<h1 class='fqn'><span class='in-band'>")?; write!(fmt, "<h1 class='fqn'><span class='in-band'>")?;
match self.item.inner { match self.item.inner {
clean::ModuleItem(ref m) => if m.is_crate { clean::ModuleItem(ref m) => if m.is_crate {
write!(fmt, "Crate ")?; write!(fmt, "Crate ")?;
@ -1741,14 +1749,11 @@ impl<'a> fmt::Display for Item<'a> {
} }
} }
write!(fmt, "</span>")?; // out-of-band write!(fmt, "</span></h1>")?; // out-of-band
write!(fmt, "</h1>\n")?;
match self.item.inner { match self.item.inner {
clean::ModuleItem(ref m) => { clean::ModuleItem(ref m) =>
item_module(fmt, self.cx, self.item, &m.items) item_module(fmt, self.cx, self.item, &m.items),
}
clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) => clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) =>
item_function(fmt, self.cx, self.item, f), item_function(fmt, self.cx, self.item, f),
clean::TraitItem(ref t) => item_trait(fmt, self.cx, self.item, t), clean::TraitItem(ref t) => item_trait(fmt, self.cx, self.item, t),
@ -2306,79 +2311,81 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
} }
} }
// Output the trait definition
write!(w, "<pre class='rust trait'>")?;
render_attributes(w, it)?;
write!(w, "{}{}{}trait {}{}{}",
VisSpace(&it.visibility),
UnsafetySpace(t.unsafety),
if t.is_auto { "auto " } else { "" },
it.name.as_ref().unwrap(),
t.generics,
bounds)?;
if !t.generics.where_predicates.is_empty() {
write!(w, "{}", WhereClause { gens: &t.generics, indent: 0, end_newline: true })?;
} else {
write!(w, " ")?;
}
let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>(); let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>(); let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
let required = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>(); let required = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>();
let provided = t.items.iter().filter(|m| m.is_method()).collect::<Vec<_>>(); let provided = t.items.iter().filter(|m| m.is_method()).collect::<Vec<_>>();
if t.items.is_empty() { // Output the trait definition
write!(w, "{{ }}")?; wrap_into_docblock(w, |w| {
} else { write!(w, "<pre class='rust trait'>")?;
// FIXME: we should be using a derived_id for the Anchors here render_attributes(w, it)?;
write!(w, "{{\n")?; write!(w, "{}{}{}trait {}{}{}",
for t in &types { VisSpace(&it.visibility),
write!(w, " ")?; UnsafetySpace(t.unsafety),
render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?; if t.is_auto { "auto " } else { "" },
write!(w, ";\n")?; it.name.as_ref().unwrap(),
} t.generics,
if !types.is_empty() && !consts.is_empty() { bounds)?;
w.write_str("\n")?;
}
for t in &consts {
write!(w, " ")?;
render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, ";\n")?;
}
if !consts.is_empty() && !required.is_empty() {
w.write_str("\n")?;
}
for (pos, m) in required.iter().enumerate() {
write!(w, " ")?;
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, ";\n")?;
if pos < required.len() - 1 { if !t.generics.where_predicates.is_empty() {
write!(w, "<div class='item-spacer'></div>")?; write!(w, "{}", WhereClause { gens: &t.generics, indent: 0, end_newline: true })?;
} } else {
write!(w, " ")?;
} }
if !required.is_empty() && !provided.is_empty() {
w.write_str("\n")?; if t.items.is_empty() {
} write!(w, "{{ }}")?;
for (pos, m) in provided.iter().enumerate() { } else {
write!(w, " ")?; // FIXME: we should be using a derived_id for the Anchors here
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?; write!(w, "{{\n")?;
match m.inner { for t in &types {
clean::MethodItem(ref inner) if !inner.generics.where_predicates.is_empty() => { write!(w, " ")?;
write!(w, ",\n {{ ... }}\n")?; render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?;
}, write!(w, ";\n")?;
_ => {
write!(w, " {{ ... }}\n")?;
},
} }
if pos < provided.len() - 1 { if !types.is_empty() && !consts.is_empty() {
write!(w, "<div class='item-spacer'></div>")?; w.write_str("\n")?;
} }
for t in &consts {
write!(w, " ")?;
render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, ";\n")?;
}
if !consts.is_empty() && !required.is_empty() {
w.write_str("\n")?;
}
for (pos, m) in required.iter().enumerate() {
write!(w, " ")?;
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, ";\n")?;
if pos < required.len() - 1 {
write!(w, "<div class='item-spacer'></div>")?;
}
}
if !required.is_empty() && !provided.is_empty() {
w.write_str("\n")?;
}
for (pos, m) in provided.iter().enumerate() {
write!(w, " ")?;
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
match m.inner {
clean::MethodItem(ref inner) if !inner.generics.where_predicates.is_empty() => {
write!(w, ",\n {{ ... }}\n")?;
},
_ => {
write!(w, " {{ ... }}\n")?;
},
}
if pos < provided.len() - 1 {
write!(w, "<div class='item-spacer'></div>")?;
}
}
write!(w, "}}")?;
} }
write!(w, "}}")?; write!(w, "</pre>")
} })?;
write!(w, "</pre>")?;
// Trait documentation // Trait documentation
document(w, cx, it)?; document(w, cx, it)?;
@ -2717,16 +2724,18 @@ fn render_assoc_item(w: &mut fmt::Formatter,
fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
s: &clean::Struct) -> fmt::Result { s: &clean::Struct) -> fmt::Result {
write!(w, "<pre class='rust struct'>")?; wrap_into_docblock(w, |w| {
render_attributes(w, it)?; write!(w, "<pre class='rust struct'>")?;
render_struct(w, render_attributes(w, it)?;
it, render_struct(w,
Some(&s.generics), it,
s.struct_type, Some(&s.generics),
&s.fields, s.struct_type,
"", &s.fields,
true)?; "",
write!(w, "</pre>")?; true)?;
write!(w, "</pre>")
})?;
document(w, cx, it)?; document(w, cx, it)?;
let mut fields = s.fields.iter().filter_map(|f| { let mut fields = s.fields.iter().filter_map(|f| {
@ -2769,15 +2778,17 @@ fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
fn item_union(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, fn item_union(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
s: &clean::Union) -> fmt::Result { s: &clean::Union) -> fmt::Result {
write!(w, "<pre class='rust union'>")?; wrap_into_docblock(w, |w| {
render_attributes(w, it)?; write!(w, "<pre class='rust union'>")?;
render_union(w, render_attributes(w, it)?;
it, render_union(w,
Some(&s.generics), it,
&s.fields, Some(&s.generics),
"", &s.fields,
true)?; "",
write!(w, "</pre>")?; true)?;
write!(w, "</pre>")
})?;
document(w, cx, it)?; document(w, cx, it)?;
let mut fields = s.fields.iter().filter_map(|f| { let mut fields = s.fields.iter().filter_map(|f| {
@ -2807,56 +2818,58 @@ fn item_union(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
e: &clean::Enum) -> fmt::Result { e: &clean::Enum) -> fmt::Result {
write!(w, "<pre class='rust enum'>")?; wrap_into_docblock(w, |w| {
render_attributes(w, it)?; write!(w, "<pre class='rust enum'>")?;
write!(w, "{}enum {}{}{}", render_attributes(w, it)?;
VisSpace(&it.visibility), write!(w, "{}enum {}{}{}",
it.name.as_ref().unwrap(), VisSpace(&it.visibility),
e.generics, it.name.as_ref().unwrap(),
WhereClause { gens: &e.generics, indent: 0, end_newline: true })?; e.generics,
if e.variants.is_empty() && !e.variants_stripped { WhereClause { gens: &e.generics, indent: 0, end_newline: true })?;
write!(w, " {{}}")?; if e.variants.is_empty() && !e.variants_stripped {
} else { write!(w, " {{}}")?;
write!(w, " {{\n")?; } else {
for v in &e.variants { write!(w, " {{\n")?;
write!(w, " ")?; for v in &e.variants {
let name = v.name.as_ref().unwrap(); write!(w, " ")?;
match v.inner { let name = v.name.as_ref().unwrap();
clean::VariantItem(ref var) => { match v.inner {
match var.kind { clean::VariantItem(ref var) => {
clean::VariantKind::CLike => write!(w, "{}", name)?, match var.kind {
clean::VariantKind::Tuple(ref tys) => { clean::VariantKind::CLike => write!(w, "{}", name)?,
write!(w, "{}(", name)?; clean::VariantKind::Tuple(ref tys) => {
for (i, ty) in tys.iter().enumerate() { write!(w, "{}(", name)?;
if i > 0 { for (i, ty) in tys.iter().enumerate() {
write!(w, ",&nbsp;")? if i > 0 {
write!(w, ",&nbsp;")?
}
write!(w, "{}", *ty)?;
} }
write!(w, "{}", *ty)?; write!(w, ")")?;
}
clean::VariantKind::Struct(ref s) => {
render_struct(w,
v,
None,
s.struct_type,
&s.fields,
" ",
false)?;
} }
write!(w, ")")?;
}
clean::VariantKind::Struct(ref s) => {
render_struct(w,
v,
None,
s.struct_type,
&s.fields,
" ",
false)?;
} }
} }
_ => unreachable!()
} }
_ => unreachable!() write!(w, ",\n")?;
} }
write!(w, ",\n")?;
}
if e.variants_stripped { if e.variants_stripped {
write!(w, " // some variants omitted\n")?; write!(w, " // some variants omitted\n")?;
}
write!(w, "}}")?;
} }
write!(w, "}}")?; write!(w, "</pre>")
} })?;
write!(w, "</pre>")?;
document(w, cx, it)?; document(w, cx, it)?;
if !e.variants.is_empty() { if !e.variants.is_empty() {
@ -4043,11 +4056,13 @@ impl<'a> fmt::Display for Source<'a> {
fn item_macro(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, fn item_macro(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Macro) -> fmt::Result { t: &clean::Macro) -> fmt::Result {
w.write_str(&highlight::render_with_highlighting(&t.source, wrap_into_docblock(w, |w| {
Some("macro"), w.write_str(&highlight::render_with_highlighting(&t.source,
None, Some("macro"),
None, None,
None))?; None,
None))
})?;
document(w, cx, it) document(w, cx, it)
} }

18
src/librustdoc/html/static/main.js
View file

@ -1833,11 +1833,16 @@
onEach(e.getElementsByClassName('associatedconstant'), func); onEach(e.getElementsByClassName('associatedconstant'), func);
}); });
function createToggle() { function createToggle(otherMessage) {
var span = document.createElement('span'); var span = document.createElement('span');
span.className = 'toggle-label'; span.className = 'toggle-label';
span.style.display = 'none'; span.style.display = 'none';
span.innerHTML = '&nbsp;Expand&nbsp;description'; if (!otherMessage) {
span.innerHTML = '&nbsp;Expand&nbsp;description';
} else {
span.innerHTML = otherMessage;
span.style.fontSize = '20px';
}
var mainToggle = toggle.cloneNode(true); var mainToggle = toggle.cloneNode(true);
mainToggle.appendChild(span); mainToggle.appendChild(span);
@ -1850,7 +1855,14 @@
onEach(document.getElementById('main').getElementsByClassName('docblock'), function(e) { onEach(document.getElementById('main').getElementsByClassName('docblock'), function(e) {
if (e.parentNode.id === "main") { if (e.parentNode.id === "main") {
e.parentNode.insertBefore(createToggle(), e); var otherMessage;
if (hasClass(e, "type-decl")) {
otherMessage = '&nbsp;Show&nbsp;type&nbsp;declaration';
}
e.parentNode.insertBefore(createToggle(otherMessage), e);
if (otherMessage) {
collapseDocs(e.previousSibling.childNodes[0], "toggle");
}
} }
}); });