bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rustdoc: Represent item types as a small number in the search index.

Browse source 
Has negligible improvements with gzip, but saves about 7% without it.
This also has an effect of changing the tie-breaking order of item types.
This commit is contained in:
Kang Seonghoon 2014-04-09 16:49:31 +09:00
parent ab6915d7b5
commit f1de04c760
5 changed files with 158 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -52,6 +52,8 @@ use rustc::util::nodemap::NodeSet;
use clean;
use doctree;
use fold::DocFolder;
use html::item_type;
use html::item_type::{ItemType, shortty};
use html::format::{VisSpace, Method, FnStyleSpace};
use html::layout;
use html::markdown;
@ -138,7 +140,7 @@ pub struct Cache {
/// URLs when a type is being linked to. External paths are not located in
/// this map because the `External` type itself has all the information
/// necessary.
pub paths: HashMap<ast::NodeId, (Vec<~str> , &'static str)>,
pub paths: HashMap<ast::NodeId, (Vec<~str> , ItemType)>,
/// This map contains information about all known traits of this crate.
/// Implementations of a crate should inherit the documentation of the
@ -193,7 +195,7 @@ struct Sidebar<'a> { cx: &'a Context, item: &'a clean::Item, }
/// Struct representing one entry in the JS search index. These are all emitted
/// by hand to a large JS file at the end of cache-creation.
struct IndexItem {
ty: &'static str,
ty: ItemType,
name: ~str,
path: ~str,
desc: ~str,
@ -311,7 +313,7 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
if i > 0 {
try!(write!(&mut w, ","));
}
try!(write!(&mut w, "\\{ty:\"{}\",name:\"{}\",path:\"{}\",desc:{}",
try!(write!(&mut w, "\\{ty:{:u},name:\"{}\",path:\"{}\",desc:{}",
item.ty, item.name, item.path,
item.desc.to_json().to_str()));
match item.parent {
@ -330,7 +332,7 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
if i > 0 {
try!(write!(&mut w, ","));
}
try!(write!(&mut w, "\\{type:'{}',name:'{}'\\}",
try!(write!(&mut w, "\\{type:{:u},name:'{}'\\}",
short, *fqp.last().unwrap()));
}
try!(write!(&mut w, "];"));
@ -622,12 +624,13 @@ impl DocFolder for Cache {
} else {
let last = self.parent_stack.last().unwrap();
let path = match self.paths.find(last) {
Some(&(_, "trait")) =>
Some(&(_, item_type::Trait)) =>
Some(self.stack.slice_to(self.stack.len() - 1)),
// The current stack not necessarily has correlation for
// where the type was defined. On the other hand,
// `paths` always has the right information if present.
Some(&(ref fqp, "struct")) | Some(&(ref fqp, "enum")) =>
Some(&(ref fqp, item_type::Struct)) |
Some(&(ref fqp, item_type::Enum)) =>
Some(fqp.slice_to(fqp.len() - 1)),
Some(..) => Some(self.stack.as_slice()),
None => None
@ -687,7 +690,7 @@ impl DocFolder for Cache {
clean::VariantItem(..) => {
let mut stack = self.stack.clone();
stack.pop();
self.paths.insert(item.id, (stack, "enum"));
self.paths.insert(item.id, (stack, item_type::Enum));
}
_ => {}
}
@ -845,7 +848,7 @@ impl Context {
}
title.push_str(" - Rust");
let page = layout::Page {
ty: shortty(it),
ty: shortty(it).to_static_str(),
root_path: cx.root_path.as_slice(),
title: title.as_slice(),
};
@ -899,27 +902,6 @@ impl Context {
}
}
fn shortty(item: &clean::Item) -> &'static str {
match item.inner {
clean::ModuleItem(..) => "mod",
clean::StructItem(..) => "struct",
clean::EnumItem(..) => "enum",
clean::FunctionItem(..) => "fn",
clean::TypedefItem(..) => "typedef",
clean::StaticItem(..) => "static",
clean::TraitItem(..) => "trait",
clean::ImplItem(..) => "impl",
clean::ViewItemItem(..) => "viewitem",
clean::TyMethodItem(..) => "tymethod",
clean::MethodItem(..) => "method",
clean::StructFieldItem(..) => "structfield",
clean::VariantItem(..) => "variant",
clean::ForeignFunctionItem(..) => "ffi",
clean::ForeignStaticItem(..) => "ffs",
clean::MacroItem(..) => "macro",
}
}
impl<'a> Item<'a> {
fn ismodule(&self) -> bool {
match self.item.inner {
@ -1009,7 +991,7 @@ impl<'a> fmt::Show for Item<'a> {
fn item_path(item: &clean::Item) -> ~str {
match item.inner {
clean::ModuleItem(..) => *item.name.get_ref() + "/index.html",
_ => shortty(item) + "." + *item.name.get_ref() + ".html"
_ => shortty(item).to_static_str() + "." + *item.name.get_ref() + ".html"
}
}
@ -1095,13 +1077,13 @@ fn item_module(w: &mut Writer, cx: &Context,
indices.sort_by(|&i1, &i2| cmp(&items[i1], &items[i2], i1, i2));
debug!("{:?}", indices);
let mut curty = "";
let mut curty = None;
for &idx in indices.iter() {
let myitem = &items[idx];
let myty = shortty(myitem);
let myty = Some(shortty(myitem));
if myty != curty {
if curty != "" {
if curty.is_some() {
try!(write!(w, "</table>"));
}
curty = myty;
@ -1704,8 +1686,9 @@ impl<'a> fmt::Show for Sidebar<'a> {
};
try!(write!(w, "<div class='block {}'><h2>{}</h2>", short, longty));
for item in items.iter() {
let curty = shortty(cur).to_static_str();
let class = if cur.name.get_ref() == item &&
short == shortty(cur) { "current" } else { "" };
short == curty { "current" } else { "" };
try!(write!(w, "<a class='{ty} {class}' href='{curty, select,
mod{../}
other{}
@ -1716,7 +1699,7 @@ impl<'a> fmt::Show for Sidebar<'a> {
ty = short,
tysel = short,
class = class,
curty = shortty(cur),
curty = curty,
name = item.as_slice()));
}
try!(write!(w, "</div>"));
@ -1735,7 +1718,7 @@ impl<'a> fmt::Show for Sidebar<'a> {
fn build_sidebar(m: &clean::Module) -> HashMap<~str, Vec<~str> > {
let mut map = HashMap::new();
for item in m.items.iter() {
let short = shortty(item);
let short = shortty(item).to_static_str();
let myname = match item.name {
None => continue,
Some(ref s) => s.to_owned(),