bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rustdoc: Refactor tests

Browse source
This commit is contained in:
Brian Anderson 2012-01-31 18:32:37 -08:00
parent 496205c85f
commit fee9037765
8 changed files with 246 additions and 530 deletions
Download patch file Download diff file Expand all files Collapse all files

138
src/rustdoc/attr_pass.rs
View file

@ -56,11 +56,7 @@ fn fold_crate(
#[test] #[test]
fn should_replace_top_module_name_with_crate_name() { fn should_replace_top_module_name_with_crate_name() {
let source = "#[link(name = \"bond\")];"; let doc = test::mk_doc("#[link(name = \"bond\")];");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let fold = fold::default_seq_fold(srv);
let doc = fold_crate(fold, doc);
assert doc.topmod.name == "bond"; assert doc.topmod.name == "bond";
} }
@ -106,22 +102,14 @@ fn fold_mod(fold: fold::fold<astsrv::srv>, doc: doc::moddoc) -> doc::moddoc {
#[test] #[test]
fn fold_mod_should_extract_mod_attributes() { fn fold_mod_should_extract_mod_attributes() {
let source = "#[doc = \"test\"] mod a { }"; let doc = test::mk_doc("#[doc = \"test\"] mod a { }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.mods()[0].desc == some("test");
let doc = extract::from_srv(srv, "");
let fold = fold::default_seq_fold(srv);
let doc = fold_mod(fold, doc.topmod.mods()[0]);
assert doc.desc == some("test");
} }
#[test] #[test]
fn fold_mod_should_extract_top_mod_attributes() { fn fold_mod_should_extract_top_mod_attributes() {
let source = "#[doc = \"test\"];"; let doc = test::mk_doc("#[doc = \"test\"];");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.desc == some("test");
let doc = extract::from_srv(srv, "");
let fold = fold::default_seq_fold(srv);
let doc = fold_mod(fold, doc.topmod);
assert doc.desc == some("test");
} }
fn fold_fn( fn fold_fn(
@ -182,22 +170,14 @@ fn merge_ret_attrs(
#[test] #[test]
fn fold_fn_should_extract_fn_attributes() { fn fold_fn_should_extract_fn_attributes() {
let source = "#[doc = \"test\"] fn a() -> int { }"; let doc = test::mk_doc("#[doc = \"test\"] fn a() -> int { }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.fns()[0].desc == some("test");
let doc = extract::from_srv(srv, "");
let fold = fold::default_seq_fold(srv);
let doc = fold_fn(fold, doc.topmod.fns()[0]);
assert doc.desc == some("test");
} }
#[test] #[test]
fn fold_fn_should_extract_arg_attributes() { fn fold_fn_should_extract_arg_attributes() {
let source = "#[doc(args(a = \"b\"))] fn c(a: bool) { }"; let doc = test::mk_doc("#[doc(args(a = \"b\"))] fn c(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.fns()[0].args[0].desc == some("b");
let doc = extract::from_srv(srv, "");
let fold = fold::default_seq_fold(srv);
let doc = fold_fn(fold, doc.topmod.fns()[0]);
assert doc.args[0].desc == some("b");
} }
#[test] #[test]
@ -224,12 +204,8 @@ fn fold_fn_should_preserve_sig() {
#[test] #[test]
fn fold_fn_should_extract_failure_conditions() { fn fold_fn_should_extract_failure_conditions() {
let source = "#[doc(failure = \"what\")] fn a() { }"; let doc = test::mk_doc("#[doc(failure = \"what\")] fn a() { }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.fns()[0].failure == some("what");
let doc = extract::from_srv(srv, "");
let fold = fold::default_seq_fold(srv);
let doc = fold_fn(fold, doc.topmod.fns()[0]);
assert doc.failure == some("what");
} }
fn fold_const( fn fold_const(
@ -248,14 +224,10 @@ fn fold_const(
#[test] #[test]
fn fold_const_should_extract_docs() { fn fold_const_should_extract_docs() {
let source = "#[doc(brief = \"foo\", desc = \"bar\")]\ let doc = test::mk_doc("#[doc(brief = \"foo\", desc = \"bar\")]\
const a: bool = true;"; const a: bool = true;");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.consts()[0].brief == some("foo");
let doc = extract::from_srv(srv, ""); assert doc.topmod.consts()[0].desc == some("bar");
let fold = fold::default_seq_fold(srv);
let doc = fold_const(fold, doc.topmod.consts()[0]);
assert doc.brief == some("foo");
assert doc.desc == some("bar");
} }
fn fold_enum( fn fold_enum(
@ -296,24 +268,16 @@ fn fold_enum(
#[test] #[test]
fn fold_enum_should_extract_docs() { fn fold_enum_should_extract_docs() {
let source = "#[doc(brief = \"a\", desc = \"b\")]\ let doc = test::mk_doc("#[doc(brief = \"a\", desc = \"b\")]\
enum a { v }"; enum a { v }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.enums()[0].brief == some("a");
let doc = extract::from_srv(srv, ""); assert doc.topmod.enums()[0].desc == some("b");
let fold = fold::default_seq_fold(srv);
let doc = fold_enum(fold, doc.topmod.enums()[0]);
assert doc.brief == some("a");
assert doc.desc == some("b");
} }
#[test] #[test]
fn fold_enum_should_extract_variant_docs() { fn fold_enum_should_extract_variant_docs() {
let source = "enum a { #[doc = \"c\"] v }"; let doc = test::mk_doc("enum a { #[doc = \"c\"] v }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.enums()[0].variants[0].desc == some("c");
let doc = extract::from_srv(srv, "");
let fold = fold::default_seq_fold(srv);
let doc = fold_enum(fold, doc.topmod.enums()[0]);
assert doc.variants[0].desc == some("c");
} }
fn fold_res( fn fold_res(
@ -346,26 +310,18 @@ fn fold_res(
#[test] #[test]
fn fold_res_should_extract_docs() { fn fold_res_should_extract_docs() {
let source = "#[doc(brief = \"a\", desc = \"b\")]\ let doc = test::mk_doc("#[doc(brief = \"a\", desc = \"b\")]\
resource r(b: bool) { }"; resource r(b: bool) { }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.resources()[0].brief == some("a");
let doc = extract::from_srv(srv, ""); assert doc.topmod.resources()[0].desc == some("b");
let fold = fold::default_seq_fold(srv);
let doc = fold_res(fold, doc.topmod.resources()[0]);
assert doc.brief == some("a");
assert doc.desc == some("b");
} }
#[test] #[test]
fn fold_res_should_extract_arg_docs() { fn fold_res_should_extract_arg_docs() {
let source = "#[doc(args(a = \"b\"))]\ let doc = test::mk_doc("#[doc(args(a = \"b\"))]\
resource r(a: bool) { }"; resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source); assert doc.topmod.resources()[0].args[0].name == "a";
let doc = extract::from_srv(srv, ""); assert doc.topmod.resources()[0].args[0].desc == some("b");
let fold = fold::default_seq_fold(srv);
let doc = fold_res(fold, doc.topmod.resources()[0]);
assert doc.args[0].name == "a";
assert doc.args[0].desc == some("b");
} }
fn fold_iface( fn fold_iface(
@ -427,16 +383,14 @@ fn merge_method_attrs(
#[test] #[test]
fn should_extract_iface_docs() { fn should_extract_iface_docs() {
let source = "#[doc = \"whatever\"] iface i { fn a(); }"; let doc = test::mk_doc("#[doc = \"whatever\"] iface i { fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.ifaces()[0].desc == some("whatever"); assert doc.topmod.ifaces()[0].desc == some("whatever");
} }
#[test] #[test]
fn should_extract_iface_method_docs() { fn should_extract_iface_method_docs() {
let source = "iface i {\ let doc = test::mk_doc(
"iface i {\
#[doc(\ #[doc(\
brief = \"brief\",\ brief = \"brief\",\
desc = \"desc\",\ desc = \"desc\",\
@ -444,10 +398,7 @@ fn should_extract_iface_method_docs() {
return = \"return\",\ return = \"return\",\
failure = \"failure\")]\ failure = \"failure\")]\
fn f(a: bool) -> bool;\ fn f(a: bool) -> bool;\
}"; }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].brief == some("brief"); assert doc.topmod.ifaces()[0].methods[0].brief == some("brief");
assert doc.topmod.ifaces()[0].methods[0].desc == some("desc"); assert doc.topmod.ifaces()[0].methods[0].desc == some("desc");
assert doc.topmod.ifaces()[0].methods[0].args[0].desc == some("a"); assert doc.topmod.ifaces()[0].methods[0].args[0].desc == some("a");
@ -474,16 +425,15 @@ fn fold_impl(
#[test] #[test]
fn should_extract_impl_docs() { fn should_extract_impl_docs() {
let source = "#[doc = \"whatever\"] impl i for int { fn a() { } }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "#[doc = \"whatever\"] impl i for int { fn a() { } }");
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].desc == some("whatever"); assert doc.topmod.impls()[0].desc == some("whatever");
} }
#[test] #[test]
fn should_extract_impl_method_docs() { fn should_extract_impl_method_docs() {
let source = "impl i for int {\ let doc = test::mk_doc(
"impl i for int {\
#[doc(\ #[doc(\
brief = \"brief\",\ brief = \"brief\",\
desc = \"desc\",\ desc = \"desc\",\
@ -491,13 +441,19 @@ fn should_extract_impl_method_docs() {
return = \"return\",\ return = \"return\",\
failure = \"failure\")]\ failure = \"failure\")]\
fn f(a: bool) -> bool { }\ fn f(a: bool) -> bool { }\
}"; }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].methods[0].brief == some("brief"); assert doc.topmod.impls()[0].methods[0].brief == some("brief");
assert doc.topmod.impls()[0].methods[0].desc == some("desc"); assert doc.topmod.impls()[0].methods[0].desc == some("desc");
assert doc.topmod.impls()[0].methods[0].args[0].desc == some("a"); assert doc.topmod.impls()[0].methods[0].args[0].desc == some("a");
assert doc.topmod.impls()[0].methods[0].return.desc == some("return"); assert doc.topmod.impls()[0].methods[0].return.desc == some("return");
assert doc.topmod.impls()[0].methods[0].failure == some("failure"); assert doc.topmod.impls()[0].methods[0].failure == some("failure");
} }
#[cfg(test)]
mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
run(srv, doc)
}
}

91
src/rustdoc/desc_pass.rs
View file

@ -128,130 +128,95 @@ fn fold_iface(fold: fold::fold<op>, doc: doc::ifacedoc) -> doc::ifacedoc {
#[test] #[test]
fn should_execute_op_on_enum_brief() { fn should_execute_op_on_enum_brief() {
let source = "#[doc(brief = \" a \")] enum a { b }"; let doc = test::mk_doc("#[doc(brief = \" a \")] enum a { b }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.enums()[0].brief == some("a"); assert doc.topmod.enums()[0].brief == some("a");
} }
#[test] #[test]
fn should_execute_op_on_enum_desc() { fn should_execute_op_on_enum_desc() {
let source = "#[doc(desc = \" a \")] enum a { b }"; let doc = test::mk_doc("#[doc(desc = \" a \")] enum a { b }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.enums()[0].desc == some("a"); assert doc.topmod.enums()[0].desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_variant_desc() { fn should_execute_op_on_variant_desc() {
let source = "enum a { #[doc = \" a \"] b }"; let doc = test::mk_doc("enum a { #[doc = \" a \"] b }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.enums()[0].variants[0].desc == some("a"); assert doc.topmod.enums()[0].variants[0].desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_resource_brief() { fn should_execute_op_on_resource_brief() {
let source = "#[doc(brief = \" a \")] resource r(a: bool) { }"; let doc = test::mk_doc("#[doc(brief = \" a \")] resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.resources()[0].brief == some("a"); assert doc.topmod.resources()[0].brief == some("a");
} }
#[test] #[test]
fn should_execute_op_on_resource_desc() { fn should_execute_op_on_resource_desc() {
let source = "#[doc(desc = \" a \")] resource r(a: bool) { }"; let doc = test::mk_doc("#[doc(desc = \" a \")] resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.resources()[0].desc == some("a"); assert doc.topmod.resources()[0].desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_resource_args() { fn should_execute_op_on_resource_args() {
let source = "#[doc(args(a = \" a \"))] resource r(a: bool) { }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "#[doc(args(a = \" a \"))] resource r(a: bool) { }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.resources()[0].args[0].desc == some("a"); assert doc.topmod.resources()[0].args[0].desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_brief() { fn should_execute_op_on_iface_brief() {
let source = "#[doc(brief = \" a \")] iface i { fn a(); }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "#[doc(brief = \" a \")] iface i { fn a(); }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.ifaces()[0].brief == some("a"); assert doc.topmod.ifaces()[0].brief == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_desc() { fn should_execute_op_on_iface_desc() {
let source = "#[doc(desc = \" a \")] iface i { fn a(); }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "#[doc(desc = \" a \")] iface i { fn a(); }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.ifaces()[0].desc == some("a"); assert doc.topmod.ifaces()[0].desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_method_brief() { fn should_execute_op_on_iface_method_brief() {
let source = "iface i { #[doc(brief = \" a \")] fn a(); }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "iface i { #[doc(brief = \" a \")] fn a(); }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].brief == some("a"); assert doc.topmod.ifaces()[0].methods[0].brief == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_method_desc() { fn should_execute_op_on_iface_method_desc() {
let source = "iface i { #[doc(desc = \" a \")] fn a(); }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "iface i { #[doc(desc = \" a \")] fn a(); }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].desc == some("a"); assert doc.topmod.ifaces()[0].methods[0].desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_method_args() { fn should_execute_op_on_iface_method_args() {
let source = "iface i { #[doc(args(a = \" a \"))] fn a(a: bool); }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "iface i { #[doc(args(a = \" a \"))] fn a(a: bool); }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].args[0].desc == some("a"); assert doc.topmod.ifaces()[0].methods[0].args[0].desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_method_return() { fn should_execute_op_on_iface_method_return() {
let source = "iface i { #[doc(return = \" a \")] fn a() -> int; }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "iface i { #[doc(return = \" a \")] fn a() -> int; }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].return.desc == some("a"); assert doc.topmod.ifaces()[0].methods[0].return.desc == some("a");
} }
#[test] #[test]
fn should_execute_op_on_iface_method_failure_condition() { fn should_execute_op_on_iface_method_failure_condition() {
let source = "iface i { #[doc(failure = \" a \")] fn a(); }"; let doc = test::mk_doc("iface i { #[doc(failure = \" a \")] fn a(); }");
assert doc.topmod.ifaces()[0].methods[0].failure == some("a");
}
#[cfg(test)]
mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let srv = astsrv::mk_srv_from_str(source); let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, ""); let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc); let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass(str::trim)(srv, doc); mk_pass(str::trim)(srv, doc)
assert doc.topmod.ifaces()[0].methods[0].failure == some("a"); }
} }

51
src/rustdoc/desc_to_brief_pass.rs
View file

@ -106,79 +106,62 @@ fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc {
#[test] #[test]
fn should_promote_mod_desc() { fn should_promote_mod_desc() {
let source = "#[doc(desc = \"desc\")] mod m { }"; let doc = test::mk_doc("#[doc(desc = \"desc\")] mod m { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert doc.topmod.mods()[0].brief == some("desc"); assert doc.topmod.mods()[0].brief == some("desc");
assert doc.topmod.mods()[0].desc == none; assert doc.topmod.mods()[0].desc == none;
} }
#[test] #[test]
fn should_promote_const_desc() { fn should_promote_const_desc() {
let source = "#[doc(desc = \"desc\")] const a: bool = true;"; let doc = test::mk_doc("#[doc(desc = \"desc\")] const a: bool = true;");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert doc.topmod.consts()[0].brief == some("desc"); assert doc.topmod.consts()[0].brief == some("desc");
assert doc.topmod.consts()[0].desc == none; assert doc.topmod.consts()[0].desc == none;
} }
#[test] #[test]
fn should_promote_fn_desc() { fn should_promote_fn_desc() {
let source = "#[doc(desc = \"desc\")] fn a() { }"; let doc = test::mk_doc("#[doc(desc = \"desc\")] fn a() { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert doc.topmod.fns()[0].brief == some("desc"); assert doc.topmod.fns()[0].brief == some("desc");
assert doc.topmod.fns()[0].desc == none; assert doc.topmod.fns()[0].desc == none;
} }
#[test] #[test]
fn should_promote_enum_desc() { fn should_promote_enum_desc() {
let source = "#[doc(desc = \"desc\")] enum a { b }"; let doc = test::mk_doc("#[doc(desc = \"desc\")] enum a { b }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert doc.topmod.enums()[0].brief == some("desc"); assert doc.topmod.enums()[0].brief == some("desc");
assert doc.topmod.enums()[0].desc == none; assert doc.topmod.enums()[0].desc == none;
} }
#[test] #[test]
fn should_promote_resource_desc() { fn should_promote_resource_desc() {
let source = "#[doc(desc = \"desc\")] resource r(a: bool) { }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "#[doc(desc = \"desc\")] resource r(a: bool) { }");
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert doc.topmod.resources()[0].brief == some("desc"); assert doc.topmod.resources()[0].brief == some("desc");
assert doc.topmod.resources()[0].desc == none; assert doc.topmod.resources()[0].desc == none;
} }
#[test] #[test]
fn should_promote_iface_desc() { fn should_promote_iface_desc() {
let source = "#[doc(desc = \"desc\")] iface i { fn a(); }"; let doc = test::mk_doc("#[doc(desc = \"desc\")] iface i { fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert doc.topmod.ifaces()[0].brief == some("desc"); assert doc.topmod.ifaces()[0].brief == some("desc");
assert doc.topmod.ifaces()[0].desc == none; assert doc.topmod.ifaces()[0].desc == none;
} }
#[test] #[test]
fn should_promote_iface_method_desc() { fn should_promote_iface_method_desc() {
let source = "iface i { #[doc(desc = \"desc\")] fn a(); }"; let doc = test::mk_doc("iface i { #[doc(desc = \"desc\")] fn a(); }");
assert doc.topmod.ifaces()[0].methods[0].brief == some("desc");
assert doc.topmod.ifaces()[0].methods[0].desc == none;
}
#[cfg(test)]
mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let srv = astsrv::mk_srv_from_str(source); let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, ""); let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc); let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc); run(srv, doc)
assert doc.topmod.ifaces()[0].methods[0].brief == some("desc"); }
assert doc.topmod.ifaces()[0].methods[0].desc == none;
} }
fn modify( fn modify(

81
src/rustdoc/extract.rs
View file

@ -145,9 +145,7 @@ fn constdoc_from_const(
#[test] #[test]
fn should_extract_const_name_and_id() { fn should_extract_const_name_and_id() {
let source = "const a: int = 0;"; let doc = test::mk_doc("const a: int = 0;");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.consts()[0].id != 0; assert doc.topmod.consts()[0].id != 0;
assert doc.topmod.consts()[0].name == "a"; assert doc.topmod.consts()[0].name == "a";
} }
@ -182,18 +180,14 @@ fn variantdoc_from_variant(variant: ast::variant) -> doc::variantdoc {
#[test] #[test]
fn should_extract_enums() { fn should_extract_enums() {
let source = "enum e { v }"; let doc = test::mk_doc("enum e { v }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.enums()[0].id != 0; assert doc.topmod.enums()[0].id != 0;
assert doc.topmod.enums()[0].name == "e"; assert doc.topmod.enums()[0].name == "e";
} }
#[test] #[test]
fn should_extract_enum_variants() { fn should_extract_enum_variants() {
let source = "enum e { v }"; let doc = test::mk_doc("enum e { v }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.enums()[0].variants[0].name == "v"; assert doc.topmod.enums()[0].variants[0].name == "v";
} }
@ -214,18 +208,14 @@ fn resdoc_from_resource(
#[test] #[test]
fn should_extract_resources() { fn should_extract_resources() {
let source = "resource r(b: bool) { }"; let doc = test::mk_doc("resource r(b: bool) { }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.resources()[0].id != 0; assert doc.topmod.resources()[0].id != 0;
assert doc.topmod.resources()[0].name == "r"; assert doc.topmod.resources()[0].name == "r";
} }
#[test] #[test]
fn should_extract_resource_args() { fn should_extract_resource_args() {
let source = "resource r(b: bool) { }"; let doc = test::mk_doc("resource r(b: bool) { }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.resources()[0].args[0].name == "b"; assert doc.topmod.resources()[0].args[0].name == "b";
} }
@ -258,25 +248,19 @@ fn ifacedoc_from_iface(
#[test] #[test]
fn should_extract_ifaces() { fn should_extract_ifaces() {
let source = "iface i { fn f(); }"; let doc = test::mk_doc("iface i { fn f(); }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.ifaces()[0].name == "i"; assert doc.topmod.ifaces()[0].name == "i";
} }
#[test] #[test]
fn should_extract_iface_methods() { fn should_extract_iface_methods() {
let source = "iface i { fn f(); }"; let doc = test::mk_doc("iface i { fn f(); }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.ifaces()[0].methods[0].name == "f"; assert doc.topmod.ifaces()[0].methods[0].name == "f";
} }
#[test] #[test]
fn should_extract_iface_method_args() { fn should_extract_iface_method_args() {
let source = "iface i { fn f(a: bool); }"; let doc = test::mk_doc("iface i { fn f(a: bool); }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.ifaces()[0].methods[0].args[0].name == "a"; assert doc.topmod.ifaces()[0].methods[0].args[0].name == "a";
} }
@ -311,53 +295,46 @@ fn impldoc_from_impl(
#[test] #[test]
fn should_extract_impls_with_names() { fn should_extract_impls_with_names() {
let source = "impl i for int { fn a() { } }"; let doc = test::mk_doc("impl i for int { fn a() { } }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.impls()[0].name == "i"; assert doc.topmod.impls()[0].name == "i";
} }
#[test] #[test]
fn should_extract_impls_without_names() { fn should_extract_impls_without_names() {
let source = "impl of i for int { fn a() { } }"; let doc = test::mk_doc("impl of i for int { fn a() { } }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.impls()[0].name == "i"; assert doc.topmod.impls()[0].name == "i";
} }
#[test] #[test]
fn should_extract_impl_methods() { fn should_extract_impl_methods() {
let source = "impl i for int { fn f() { } }"; let doc = test::mk_doc("impl i for int { fn f() { } }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.impls()[0].methods[0].name == "f"; assert doc.topmod.impls()[0].methods[0].name == "f";
} }
#[test] #[test]
fn should_extract_impl_method_args() { fn should_extract_impl_method_args() {
let source = "impl i for int { fn f(a: bool) { } }"; let doc = test::mk_doc("impl i for int { fn f(a: bool) { } }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.impls()[0].methods[0].args[0].name == "a"; assert doc.topmod.impls()[0].methods[0].args[0].name == "a";
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let ast = parse::from_str(source);
extract(ast, "")
}
#[test] #[test]
fn extract_empty_crate() { fn extract_empty_crate() {
let source = ""; // empty crate let doc = mk_doc("");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert vec::is_empty(doc.topmod.mods()); assert vec::is_empty(doc.topmod.mods());
assert vec::is_empty(doc.topmod.fns()); assert vec::is_empty(doc.topmod.fns());
} }
#[test] #[test]
fn extract_mods() { fn extract_mods() {
let source = "mod a { mod b { } mod c { } }"; let doc = mk_doc("mod a { mod b { } mod c { } }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.mods()[0].name == "a"; assert doc.topmod.mods()[0].name == "a";
assert doc.topmod.mods()[0].mods()[0].name == "b"; assert doc.topmod.mods()[0].mods()[0].name == "b";
assert doc.topmod.mods()[0].mods()[1].name == "c"; assert doc.topmod.mods()[0].mods()[1].name == "c";
@ -365,36 +342,28 @@ mod tests {
#[test] #[test]
fn extract_mods_deep() { fn extract_mods_deep() {
let source = "mod a { mod b { mod c { } } }"; let doc = mk_doc("mod a { mod b { mod c { } } }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.mods()[0].mods()[0].mods()[0].name == "c"; assert doc.topmod.mods()[0].mods()[0].mods()[0].name == "c";
} }
#[test] #[test]
fn extract_should_set_mod_ast_id() { fn extract_should_set_mod_ast_id() {
let source = "mod a { }"; let doc = mk_doc("mod a { }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.mods()[0].id != 0; assert doc.topmod.mods()[0].id != 0;
} }
#[test] #[test]
fn extract_fns() { fn extract_fns() {
let source = let doc = mk_doc(
"fn a() { } \ "fn a() { } \
mod b { fn c() { } }"; mod b { fn c() { } }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.fns()[0].name == "a"; assert doc.topmod.fns()[0].name == "a";
assert doc.topmod.mods()[0].fns()[0].name == "c"; assert doc.topmod.mods()[0].fns()[0].name == "c";
} }
#[test] #[test]
fn extract_should_set_fn_ast_id() { fn extract_should_set_fn_ast_id() {
let source = "fn a() { }"; let doc = mk_doc("fn a() { }");
let ast = parse::from_str(source);
let doc = extract(ast, "");
assert doc.topmod.fns()[0].id != 0; assert doc.topmod.fns()[0].id != 0;
} }

126
src/rustdoc/prune_undoc_pass.rs
View file

@ -138,21 +138,13 @@ fn prune_return(doc: doc::retdoc) -> doc::retdoc {
#[test] #[test]
fn should_elide_undocumented_arguments() { fn should_elide_undocumented_arguments() {
let source = "#[doc = \"hey\"] fn a(b: int) { }"; let doc = test::mk_doc("#[doc = \"hey\"] fn a(b: int) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.fns()[0].args); assert vec::is_empty(doc.topmod.fns()[0].args);
} }
#[test] #[test]
fn should_not_elide_fns_with_documented_arguments() { fn should_not_elide_fns_with_documented_arguments() {
let source = "#[doc(args(a = \"b\"))] fn a(a: int) { }"; let doc = test::mk_doc("#[doc(args(a = \"b\"))] fn a(a: int) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.fns()); assert vec::is_not_empty(doc.topmod.fns());
} }
@ -169,49 +161,31 @@ fn should_elide_undocumented_return_values() {
#[test] #[test]
fn should_not_elide_fns_with_documented_failure_conditions() { fn should_not_elide_fns_with_documented_failure_conditions() {
let source = "#[doc(failure = \"yup\")] fn a() { }"; let doc = test::mk_doc("#[doc(failure = \"yup\")] fn a() { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.fns()); assert vec::is_not_empty(doc.topmod.fns());
} }
#[test] #[test]
fn should_elide_undocumented_mods() { fn should_elide_undocumented_mods() {
let source = "mod a { }"; let doc = test::mk_doc("mod a { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.mods()); assert vec::is_empty(doc.topmod.mods());
} }
#[test] #[test]
fn should_not_elide_undocument_mods_with_documented_mods() { fn should_not_elide_undocument_mods_with_documented_mods() {
let source = "mod a { #[doc = \"b\"] mod b { } }"; let doc = test::mk_doc("mod a { #[doc = \"b\"] mod b { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.mods()); assert vec::is_not_empty(doc.topmod.mods());
} }
#[test] #[test]
fn should_not_elide_undocument_mods_with_documented_fns() { fn should_not_elide_undocument_mods_with_documented_fns() {
let source = "mod a { #[doc = \"b\"] fn b() { } }"; let doc = test::mk_doc("mod a { #[doc = \"b\"] fn b() { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.mods()); assert vec::is_not_empty(doc.topmod.mods());
} }
#[test] #[test]
fn should_elide_undocumented_fns() { fn should_elide_undocumented_fns() {
let source = "fn a() { }"; let doc = test::mk_doc("fn a() { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.fns()); assert vec::is_empty(doc.topmod.fns());
} }
@ -228,10 +202,7 @@ fn fold_const(
#[test] #[test]
fn should_elide_undocumented_consts() { fn should_elide_undocumented_consts() {
let source = "const a: bool = true;"; let doc = test::mk_doc("const a: bool = true;");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.consts()); assert vec::is_empty(doc.topmod.consts());
} }
@ -255,31 +226,19 @@ fn fold_enum(fold: fold::fold<ctxt>, doc: doc::enumdoc) -> doc::enumdoc {
#[test] #[test]
fn should_elide_undocumented_enums() { fn should_elide_undocumented_enums() {
let source = "enum a { b }"; let doc = test::mk_doc("enum a { b }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.enums()); assert vec::is_empty(doc.topmod.enums());
} }
#[test] #[test]
fn should_elide_undocumented_variants() { fn should_elide_undocumented_variants() {
let source = "#[doc = \"a\"] enum a { b }"; let doc = test::mk_doc("#[doc = \"a\"] enum a { b }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.enums()[0].variants); assert vec::is_empty(doc.topmod.enums()[0].variants);
} }
#[test] #[test]
fn should_not_elide_enums_with_documented_variants() { fn should_not_elide_enums_with_documented_variants() {
let source = "enum a { #[doc = \"a\"] b }"; let doc = test::mk_doc("enum a { #[doc = \"a\"] b }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.enums()); assert vec::is_not_empty(doc.topmod.enums());
} }
@ -303,32 +262,21 @@ fn fold_res(fold: fold::fold<ctxt>, doc: doc::resdoc) -> doc::resdoc {
#[test] #[test]
fn should_elide_undocumented_resources() { fn should_elide_undocumented_resources() {
let source = "resource r(a: bool) { }"; let doc = test::mk_doc("resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.resources()); assert vec::is_empty(doc.topmod.resources());
} }
#[test] #[test]
fn should_elide_undocumented_resource_args() { fn should_elide_undocumented_resource_args() {
let source = "#[doc = \"drunk\"]\ let doc = test::mk_doc("#[doc = \"drunk\"]\
resource r(a: bool) { }"; resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.resources()[0].args); assert vec::is_empty(doc.topmod.resources()[0].args);
} }
#[test] #[test]
fn should_not_elide_resources_with_documented_args() { fn should_not_elide_resources_with_documented_args() {
let source = "#[doc(args(a = \"drunk\"))]\ let doc = test::mk_doc("#[doc(args(a = \"drunk\"))]\
resource r(a: bool) { }"; resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.resources()); assert vec::is_not_empty(doc.topmod.resources());
} }
@ -364,60 +312,46 @@ fn fold_iface(
#[test] #[test]
fn should_elide_undocumented_ifaces() { fn should_elide_undocumented_ifaces() {
let source = "iface i { fn a(); }"; let doc = test::mk_doc("iface i { fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.ifaces()); assert vec::is_empty(doc.topmod.ifaces());
} }
#[test] #[test]
fn should_not_elide_documented_ifaces() { fn should_not_elide_documented_ifaces() {
let source = "#[doc = \"hey\"] iface i { fn a(); }"; let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.ifaces()); assert vec::is_not_empty(doc.topmod.ifaces());
} }
#[test] #[test]
fn should_not_elide_ifaces_with_documented_methods() { fn should_not_elide_ifaces_with_documented_methods() {
let source = "iface i { #[doc = \"hey\"] fn a(); }"; let doc = test::mk_doc("iface i { #[doc = \"hey\"] fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.ifaces()); assert vec::is_not_empty(doc.topmod.ifaces());
} }
#[test] #[test]
fn should_not_elide_undocumented_methods() { fn should_not_elide_undocumented_methods() {
let source = "#[doc = \"hey\"] iface i { fn a(); }"; let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_not_empty(doc.topmod.ifaces()[0].methods); assert vec::is_not_empty(doc.topmod.ifaces()[0].methods);
} }
#[test] #[test]
fn should_elide_undocumented_method_args() { fn should_elide_undocumented_method_args() {
let source = "#[doc = \"hey\"] iface i { fn a(); }"; let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.ifaces()[0].methods[0].args); assert vec::is_empty(doc.topmod.ifaces()[0].methods[0].args);
} }
#[test] #[test]
fn should_elide_undocumented_method_return_values() { fn should_elide_undocumented_method_return_values() {
let source = "#[doc = \"hey\"] iface i { fn a() -> int; }"; let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a() -> int; }");
assert doc.topmod.ifaces()[0].methods[0].return.ty == none;
}
#[cfg(test)]
mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let srv = astsrv::mk_srv_from_str(source); let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, ""); let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc); let doc = attr_pass::mk_pass()(srv, doc);
let doc = run(srv, doc); run(srv, doc)
assert doc.topmod.ifaces()[0].methods[0].return.ty == none; }
} }

85
src/rustdoc/prune_unexported_pass.rs
View file

@ -132,128 +132,99 @@ fn is_exported_from_crate(
#[test] #[test]
fn should_prune_unexported_fns() { fn should_prune_unexported_fns() {
let source = "mod b { export a; fn a() { } fn b() { } }"; let doc = test::mk_doc("mod b { export a; fn a() { } fn b() { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.mods()[0].fns()) == 1u; assert vec::len(doc.topmod.mods()[0].fns()) == 1u;
} }
#[test] #[test]
fn should_prune_unexported_fns_from_top_mod() { fn should_prune_unexported_fns_from_top_mod() {
let source = "export a; fn a() { } fn b() { }"; let doc = test::mk_doc("export a; fn a() { } fn b() { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.fns()) == 1u; assert vec::len(doc.topmod.fns()) == 1u;
} }
#[test] #[test]
fn should_prune_unexported_modules() { fn should_prune_unexported_modules() {
let source = "mod a { export a; mod a { } mod b { } }"; let doc = test::mk_doc("mod a { export a; mod a { } mod b { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.mods()[0].mods()) == 1u; assert vec::len(doc.topmod.mods()[0].mods()) == 1u;
} }
#[test] #[test]
fn should_prune_unexported_modules_from_top_mod() { fn should_prune_unexported_modules_from_top_mod() {
let source = "export a; mod a { } mod b { }"; let doc = test::mk_doc("export a; mod a { } mod b { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.mods()) == 1u; assert vec::len(doc.topmod.mods()) == 1u;
} }
#[test] #[test]
fn should_prune_unexported_consts() { fn should_prune_unexported_consts() {
let source = "mod a { export a; \ let doc = test::mk_doc(
"mod a { export a; \
const a: bool = true; \ const a: bool = true; \
const b: bool = true; }"; const b: bool = true; }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.mods()[0].consts()) == 1u; assert vec::len(doc.topmod.mods()[0].consts()) == 1u;
} }
#[test] #[test]
fn should_prune_unexported_consts_from_top_mod() { fn should_prune_unexported_consts_from_top_mod() {
let source = "export a; const a: bool = true; const b: bool = true;"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "export a; const a: bool = true; const b: bool = true;");
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.consts()) == 1u; assert vec::len(doc.topmod.consts()) == 1u;
} }
#[test] #[test]
fn should_prune_unexported_enums_from_top_mod() { fn should_prune_unexported_enums_from_top_mod() {
let source = "export a; mod a { } enum b { c }"; let doc = test::mk_doc("export a; mod a { } enum b { c }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.enums()) == 0u; assert vec::len(doc.topmod.enums()) == 0u;
} }
#[test] #[test]
fn should_prune_unexported_enums() { fn should_prune_unexported_enums() {
let source = "mod a { export a; mod a { } enum b { c } }"; let doc = test::mk_doc("mod a { export a; mod a { } enum b { c } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.mods()[0].enums()) == 0u; assert vec::len(doc.topmod.mods()[0].enums()) == 0u;
} }
#[test] #[test]
fn should_prune_unexported_variants_from_top_mod() { fn should_prune_unexported_variants_from_top_mod() {
let source = "export b::{}; enum b { c }"; let doc = test::mk_doc("export b::{}; enum b { c }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.enums()[0].variants) == 0u; assert vec::len(doc.topmod.enums()[0].variants) == 0u;
} }
#[test] #[test]
fn should_prune_unexported_variants() { fn should_prune_unexported_variants() {
let source = "mod a { export b::{}; enum b { c } }"; let doc = test::mk_doc("mod a { export b::{}; enum b { c } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::len(doc.topmod.mods()[0].enums()[0].variants) == 0u; assert vec::len(doc.topmod.mods()[0].enums()[0].variants) == 0u;
} }
#[test] #[test]
fn should_prune_unexported_resources_from_top_mod() { fn should_prune_unexported_resources_from_top_mod() {
let source = "export a; mod a { } resource r(a: bool) { }"; let doc = test::mk_doc("export a; mod a { } resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.resources()); assert vec::is_empty(doc.topmod.resources());
} }
#[test] #[test]
fn should_prune_unexported_resources() { fn should_prune_unexported_resources() {
let source = "mod a { export a; mod a { } resource r(a: bool) { } }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "mod a { export a; mod a { } resource r(a: bool) { } }");
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.mods()[0].resources()); assert vec::is_empty(doc.topmod.mods()[0].resources());
} }
#[test] #[test]
fn should_prune_unexported_ifaces_from_top_mod() { fn should_prune_unexported_ifaces_from_top_mod() {
let source = "export a; mod a { } iface b { fn c(); }"; let doc = test::mk_doc("export a; mod a { } iface b { fn c(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.ifaces()); assert vec::is_empty(doc.topmod.ifaces());
} }
#[test] #[test]
fn should_prune_unexported_impls_from_top_mod() { fn should_prune_unexported_impls_from_top_mod() {
let source = "export a; mod a { } impl b for int { fn c() { } }"; let doc = test::mk_doc(
let srv = astsrv::mk_srv_from_str(source); "export a; mod a { } impl b for int { fn c() { } }");
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert vec::is_empty(doc.topmod.impls()) assert vec::is_empty(doc.topmod.impls())
} }
#[cfg(test)]
mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
run(srv, doc)
}
}

48
src/rustdoc/trim_pass.rs
View file

@ -15,69 +15,55 @@ fn mk_pass() -> pass {
#[test] #[test]
fn should_trim_mod() { fn should_trim_mod() {
let source = "#[doc(brief = \"\nbrief\n\", \ let doc = test::mk_doc("#[doc(brief = \"\nbrief\n\", \
desc = \"\ndesc\n\")] \ desc = \"\ndesc\n\")] \
mod m { }"; mod m { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass()(srv, doc);
assert doc.topmod.mods()[0].brief == some("brief"); assert doc.topmod.mods()[0].brief == some("brief");
assert doc.topmod.mods()[0].desc == some("desc"); assert doc.topmod.mods()[0].desc == some("desc");
} }
#[test] #[test]
fn should_trim_const() { fn should_trim_const() {
let source = "#[doc(brief = \"\nbrief\n\", \ let doc = test::mk_doc("#[doc(brief = \"\nbrief\n\", \
desc = \"\ndesc\n\")] \ desc = \"\ndesc\n\")] \
const a: bool = true;"; const a: bool = true;");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass()(srv, doc);
assert doc.topmod.consts()[0].brief == some("brief"); assert doc.topmod.consts()[0].brief == some("brief");
assert doc.topmod.consts()[0].desc == some("desc"); assert doc.topmod.consts()[0].desc == some("desc");
} }
#[test] #[test]
fn should_trim_fn() { fn should_trim_fn() {
let source = "#[doc(brief = \"\nbrief\n\", \ let doc = test::mk_doc("#[doc(brief = \"\nbrief\n\", \
desc = \"\ndesc\n\")] \ desc = \"\ndesc\n\")] \
fn a() { }"; fn a() { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass()(srv, doc);
assert doc.topmod.fns()[0].brief == some("brief"); assert doc.topmod.fns()[0].brief == some("brief");
assert doc.topmod.fns()[0].desc == some("desc"); assert doc.topmod.fns()[0].desc == some("desc");
} }
#[test] #[test]
fn should_trim_args() { fn should_trim_args() {
let source = "#[doc(args(a = \"\na\n\"))] fn a(a: int) { }"; let doc = test::mk_doc("#[doc(args(a = \"\na\n\"))] fn a(a: int) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass()(srv, doc);
assert doc.topmod.fns()[0].args[0].desc == some("a"); assert doc.topmod.fns()[0].args[0].desc == some("a");
} }
#[test] #[test]
fn should_trim_ret() { fn should_trim_ret() {
let source = "#[doc(return = \"\na\n\")] fn a() -> int { }"; let doc = test::mk_doc("#[doc(return = \"\na\n\")] fn a() -> int { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass()(srv, doc);
assert doc.topmod.fns()[0].return.desc == some("a"); assert doc.topmod.fns()[0].return.desc == some("a");
} }
#[test] #[test]
fn should_trim_failure_conditions() { fn should_trim_failure_conditions() {
let source = "#[doc(failure = \"\na\n\")] fn a() -> int { }"; let doc = test::mk_doc("#[doc(failure = \"\na\n\")] fn a() -> int { }");
assert doc.topmod.fns()[0].failure == some("a");
}
#[cfg(test)]
mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let srv = astsrv::mk_srv_from_str(source); let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, ""); let doc = extract::from_srv(srv, "");
let doc = attr_pass::mk_pass()(srv, doc); let doc = attr_pass::mk_pass()(srv, doc);
let doc = mk_pass()(srv, doc); mk_pass()(srv, doc)
assert doc.topmod.fns()[0].failure == some("a"); }
} }

104
src/rustdoc/tystr_pass.rs
View file

@ -60,10 +60,7 @@ fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<str> {
#[test] #[test]
fn should_add_fn_sig() { fn should_add_fn_sig() {
let source = "fn a() -> int { }"; let doc = test::mk_doc("fn a() -> int { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.fns()[0].sig == some("fn a() -> int"); assert doc.topmod.fns()[0].sig == some("fn a() -> int");
} }
@ -107,19 +104,13 @@ fn ret_ty_to_str(decl: ast::fn_decl) -> option<str> {
#[test] #[test]
fn should_add_fn_ret_types() { fn should_add_fn_ret_types() {
let source = "fn a() -> int { }"; let doc = test::mk_doc("fn a() -> int { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.fns()[0].return.ty == some("int"); assert doc.topmod.fns()[0].return.ty == some("int");
} }
#[test] #[test]
fn should_not_add_nil_ret_type() { fn should_not_add_nil_ret_type() {
let source = "fn a() { }"; let doc = test::mk_doc("fn a() { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.fns()[0].return.ty == none; assert doc.topmod.fns()[0].return.ty == none;
} }
@ -165,10 +156,7 @@ fn decl_arg_tys(decl: ast::fn_decl) -> [(str, str)] {
#[test] #[test]
fn should_add_arg_types() { fn should_add_arg_types() {
let source = "fn a(b: int, c: bool) { }"; let doc = test::mk_doc("fn a(b: int, c: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
let fn_ = doc.topmod.fns()[0]; let fn_ = doc.topmod.fns()[0];
assert fn_.args[0].ty == some("int"); assert fn_.args[0].ty == some("int");
assert fn_.args[1].ty == some("bool"); assert fn_.args[1].ty == some("bool");
@ -199,10 +187,7 @@ fn fold_const(
#[test] #[test]
fn should_add_const_types() { fn should_add_const_types() {
let source = "const a: bool = true;"; let doc = test::mk_doc("const a: bool = true;");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.consts()[0].ty == some("bool"); assert doc.topmod.consts()[0].ty == some("bool");
} }
@ -241,10 +226,7 @@ fn fold_enum(
#[test] #[test]
fn should_add_variant_sigs() { fn should_add_variant_sigs() {
let source = "enum a { b(int) }"; let doc = test::mk_doc("enum a { b(int) }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.enums()[0].variants[0].sig == some("b(int)"); assert doc.topmod.enums()[0].variants[0].sig == some("b(int)");
} }
@ -272,19 +254,13 @@ fn fold_res(
#[test] #[test]
fn should_add_resource_sigs() { fn should_add_resource_sigs() {
let source = "resource r(b: bool) { }"; let doc = test::mk_doc("resource r(b: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.resources()[0].sig == some("resource r(b: bool)"); assert doc.topmod.resources()[0].sig == some("resource r(b: bool)");
} }
#[test] #[test]
fn should_add_resource_arg_tys() { fn should_add_resource_arg_tys() {
let source = "resource r(a: bool) { }"; let doc = test::mk_doc("resource r(a: bool) { }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.resources()[0].args[0].ty == some("bool"); assert doc.topmod.resources()[0].args[0].ty == some("bool");
} }
@ -464,37 +440,25 @@ fn get_method_arg_tys(
#[test] #[test]
fn should_add_iface_method_sigs() { fn should_add_iface_method_sigs() {
let source = "iface i { fn a() -> int; }"; let doc = test::mk_doc("iface i { fn a() -> int; }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].sig == some("fn a() -> int"); assert doc.topmod.ifaces()[0].methods[0].sig == some("fn a() -> int");
} }
#[test] #[test]
fn should_add_iface_method_ret_types() { fn should_add_iface_method_ret_types() {
let source = "iface i { fn a() -> int; }"; let doc = test::mk_doc("iface i { fn a() -> int; }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].return.ty == some("int"); assert doc.topmod.ifaces()[0].methods[0].return.ty == some("int");
} }
#[test] #[test]
fn should_not_add_iface_method_nil_ret_type() { fn should_not_add_iface_method_nil_ret_type() {
let source = "iface i { fn a(); }"; let doc = test::mk_doc("iface i { fn a(); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.ifaces()[0].methods[0].return.ty == none; assert doc.topmod.ifaces()[0].methods[0].return.ty == none;
} }
#[test] #[test]
fn should_add_iface_method_arg_types() { fn should_add_iface_method_arg_types() {
let source = "iface i { fn a(b: int, c: bool); }"; let doc = test::mk_doc("iface i { fn a(b: int, c: bool); }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
let fn_ = doc.topmod.ifaces()[0].methods[0]; let fn_ = doc.topmod.ifaces()[0].methods[0];
assert fn_.args[0].ty == some("int"); assert fn_.args[0].ty == some("int");
assert fn_.args[1].ty == some("bool"); assert fn_.args[1].ty == some("bool");
@ -531,65 +495,53 @@ fn fold_impl(
#[test] #[test]
fn should_add_impl_iface_ty() { fn should_add_impl_iface_ty() {
let source = "impl i of j for int { fn a() { } }"; let doc = test::mk_doc("impl i of j for int { fn a() { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].iface_ty == some("j"); assert doc.topmod.impls()[0].iface_ty == some("j");
} }
#[test] #[test]
fn should_not_add_impl_iface_ty_if_none() { fn should_not_add_impl_iface_ty_if_none() {
let source = "impl i for int { fn a() { } }"; let doc = test::mk_doc("impl i for int { fn a() { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].iface_ty == none; assert doc.topmod.impls()[0].iface_ty == none;
} }
#[test] #[test]
fn should_add_impl_self_ty() { fn should_add_impl_self_ty() {
let source = "impl i for int { fn a() { } }"; let doc = test::mk_doc("impl i for int { fn a() { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].self_ty == some("int"); assert doc.topmod.impls()[0].self_ty == some("int");
} }
#[test] #[test]
fn should_add_impl_method_sigs() { fn should_add_impl_method_sigs() {
let source = "impl i for int { fn a() -> int { fail } }"; let doc = test::mk_doc("impl i for int { fn a() -> int { fail } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].methods[0].sig == some("fn a() -> int"); assert doc.topmod.impls()[0].methods[0].sig == some("fn a() -> int");
} }
#[test] #[test]
fn should_add_impl_method_ret_types() { fn should_add_impl_method_ret_types() {
let source = "impl i for int { fn a() -> int { fail } }"; let doc = test::mk_doc("impl i for int { fn a() -> int { fail } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].methods[0].return.ty == some("int"); assert doc.topmod.impls()[0].methods[0].return.ty == some("int");
} }
#[test] #[test]
fn should_not_add_impl_method_nil_ret_type() { fn should_not_add_impl_method_nil_ret_type() {
let source = "impl i for int { fn a() { } }"; let doc = test::mk_doc("impl i for int { fn a() { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
assert doc.topmod.impls()[0].methods[0].return.ty == none; assert doc.topmod.impls()[0].methods[0].return.ty == none;
} }
#[test] #[test]
fn should_add_impl_method_arg_types() { fn should_add_impl_method_arg_types() {
let source = "impl i for int { fn a(b: int, c: bool) { } }"; let doc = test::mk_doc("impl i for int { fn a(b: int, c: bool) { } }");
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
let doc = run(srv, doc);
let fn_ = doc.topmod.impls()[0].methods[0]; let fn_ = doc.topmod.impls()[0].methods[0];
assert fn_.args[0].ty == some("int"); assert fn_.args[0].ty == some("int");
assert fn_.args[1].ty == some("bool"); assert fn_.args[1].ty == some("bool");
} }
#[cfg(test)]
mod test {
fn mk_doc(source: str) -> doc::cratedoc {
let srv = astsrv::mk_srv_from_str(source);
let doc = extract::from_srv(srv, "");
run(srv, doc)
}
}