2012-12-03 16:48:01 -08:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2012-09-20 16:09:46 -07:00
|
|
|
/*!
|
|
|
|
The attribute parsing pass
|
|
|
|
|
|
|
|
Traverses the document tree, pulling relevant documention out of the
|
|
|
|
corresponding AST nodes. The information gathered here is the basis
|
|
|
|
of the natural-language documentation for a crate.
|
|
|
|
*/
|
2012-01-17 17:44:32 -08:00
|
|
|
|
2013-01-08 19:37:25 -08:00
|
|
|
use core::prelude::*;
|
|
|
|
|
2012-12-23 17:41:37 -05:00
|
|
|
use astsrv;
|
|
|
|
use attr_parser;
|
2012-09-18 16:48:40 -07:00
|
|
|
use doc::ItemUtils;
|
2012-12-23 17:41:37 -05:00
|
|
|
use doc;
|
2012-09-05 10:41:47 -07:00
|
|
|
use extract::to_str;
|
2012-12-05 15:06:54 -08:00
|
|
|
use fold::Fold;
|
2012-12-23 17:41:37 -05:00
|
|
|
use fold;
|
2013-01-08 19:37:25 -08:00
|
|
|
use pass::Pass;
|
2012-12-23 17:41:37 -05:00
|
|
|
|
|
|
|
use core::option;
|
|
|
|
use core::vec;
|
2012-09-05 10:41:47 -07:00
|
|
|
use syntax::ast;
|
|
|
|
use syntax::ast_map;
|
2012-09-10 15:38:28 -07:00
|
|
|
use std::map::HashMap;
|
2012-12-23 17:41:37 -05:00
|
|
|
use std::par;
|
2012-01-16 16:05:59 -08:00
|
|
|
|
2012-11-19 18:00:12 -08:00
|
|
|
pub fn mk_pass() -> Pass {
|
2013-01-08 14:00:45 -08:00
|
|
|
Pass {
|
2012-07-13 22:57:48 -07:00
|
|
|
name: ~"attr",
|
2012-02-27 18:07:16 -08:00
|
|
|
f: run
|
|
|
|
}
|
2012-01-17 16:12:50 -08:00
|
|
|
}
|
2012-01-16 16:05:59 -08:00
|
|
|
|
2013-01-08 19:37:25 -08:00
|
|
|
pub fn run(
|
2012-09-18 16:48:40 -07:00
|
|
|
srv: astsrv::Srv,
|
2013-01-30 19:32:36 -08:00
|
|
|
doc: doc::Doc
|
2012-09-18 16:48:40 -07:00
|
|
|
) -> doc::Doc {
|
2012-12-05 15:06:54 -08:00
|
|
|
let fold = Fold {
|
2012-01-19 00:14:41 -08:00
|
|
|
fold_crate: fold_crate,
|
2012-02-17 16:52:27 -08:00
|
|
|
fold_item: fold_item,
|
2012-01-26 21:39:20 -08:00
|
|
|
fold_enum: fold_enum,
|
2012-07-03 16:30:42 -07:00
|
|
|
fold_trait: fold_trait,
|
2012-09-04 13:29:32 -07:00
|
|
|
fold_impl: fold_impl,
|
2012-12-05 15:06:54 -08:00
|
|
|
.. fold::default_any_fold(srv)
|
|
|
|
};
|
2012-11-29 17:51:16 -08:00
|
|
|
(fold.fold_doc)(&fold, doc)
|
2012-01-16 19:39:53 -08:00
|
|
|
}
|
|
|
|
|
2012-01-18 14:30:48 -08:00
|
|
|
fn fold_crate(
|
2012-11-19 18:48:46 -08:00
|
|
|
fold: &fold::Fold<astsrv::Srv>,
|
2013-01-30 19:32:36 -08:00
|
|
|
doc: doc::CrateDoc
|
2012-09-18 16:48:40 -07:00
|
|
|
) -> doc::CrateDoc {
|
2012-01-18 14:30:48 -08:00
|
|
|
|
|
|
|
let srv = fold.ctxt;
|
|
|
|
let doc = fold::default_seq_fold_crate(fold, doc);
|
|
|
|
|
2012-06-30 16:19:07 -07:00
|
|
|
let attrs = do astsrv::exec(srv) |ctxt| {
|
2013-01-30 13:14:35 -08:00
|
|
|
let attrs = copy ctxt.ast.node.attrs;
|
2012-01-18 14:30:48 -08:00
|
|
|
attr_parser::parse_crate(attrs)
|
|
|
|
};
|
|
|
|
|
2013-01-25 16:57:39 -08:00
|
|
|
doc::CrateDoc {
|
2013-01-29 19:45:53 -08:00
|
|
|
topmod: doc::ModDoc {
|
2013-01-25 16:57:39 -08:00
|
|
|
item: doc::ItemDoc {
|
2013-01-30 13:14:35 -08:00
|
|
|
name: option::get_or_default(copy attrs.name,
|
|
|
|
doc.topmod.name()),
|
|
|
|
.. copy doc.topmod.item
|
2012-09-04 13:29:32 -07:00
|
|
|
},
|
2013-01-30 13:14:35 -08:00
|
|
|
.. copy doc.topmod
|
2013-01-29 19:45:53 -08:00
|
|
|
}
|
2012-01-18 14:30:48 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn should_replace_top_module_name_with_crate_name() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"#[link(name = \"bond\")];");
|
|
|
|
assert doc.cratemod().name() == ~"bond";
|
2012-01-18 14:30:48 -08:00
|
|
|
}
|
|
|
|
|
2012-02-17 16:52:27 -08:00
|
|
|
fn fold_item(
|
2012-11-19 18:48:46 -08:00
|
|
|
fold: &fold::Fold<astsrv::Srv>,
|
2013-01-30 19:32:36 -08:00
|
|
|
doc: doc::ItemDoc
|
2012-09-18 16:48:40 -07:00
|
|
|
) -> doc::ItemDoc {
|
2012-02-17 16:52:27 -08:00
|
|
|
|
|
|
|
let srv = fold.ctxt;
|
|
|
|
let doc = fold::default_seq_fold_item(fold, doc);
|
|
|
|
|
2012-03-09 18:12:15 -08:00
|
|
|
let desc = if doc.id == ast::crate_node_id {
|
2012-02-17 16:52:27 -08:00
|
|
|
// This is the top-level mod, use the crate attributes
|
2012-06-30 16:19:07 -07:00
|
|
|
do astsrv::exec(srv) |ctxt| {
|
2013-01-30 13:14:35 -08:00
|
|
|
attr_parser::parse_desc(copy ctxt.ast.node.attrs)
|
2012-02-17 16:52:27 -08:00
|
|
|
}
|
|
|
|
} else {
|
2012-03-09 18:12:15 -08:00
|
|
|
parse_item_attrs(srv, doc.id, attr_parser::parse_desc)
|
2012-02-17 16:52:27 -08:00
|
|
|
};
|
|
|
|
|
2013-01-25 16:57:39 -08:00
|
|
|
doc::ItemDoc {
|
2012-09-04 13:29:32 -07:00
|
|
|
desc: desc,
|
|
|
|
.. doc
|
2012-02-17 16:52:27 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-11 13:50:04 -08:00
|
|
|
fn parse_item_attrs<T:Owned>(
|
2012-09-18 16:48:40 -07:00
|
|
|
srv: astsrv::Srv,
|
|
|
|
id: doc::AstId,
|
2013-01-30 19:32:36 -08:00
|
|
|
parse_attrs: fn~(a: ~[ast::attribute]) -> T) -> T {
|
2012-09-18 22:43:54 -07:00
|
|
|
do astsrv::exec(srv) |move parse_attrs, ctxt| {
|
2012-08-06 12:34:08 -07:00
|
|
|
let attrs = match ctxt.ast_map.get(id) {
|
2013-01-30 13:14:35 -08:00
|
|
|
ast_map::node_item(item, _) => copy item.attrs,
|
|
|
|
ast_map::node_foreign_item(item, _, _) => copy item.attrs,
|
2012-08-03 19:59:04 -07:00
|
|
|
_ => fail ~"parse_item_attrs: not an item"
|
2012-01-24 00:38:21 -08:00
|
|
|
};
|
|
|
|
parse_attrs(attrs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-18 18:51:04 -08:00
|
|
|
#[test]
|
2012-02-17 16:52:27 -08:00
|
|
|
fn should_should_extract_mod_attributes() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"#[doc = \"test\"] mod a { }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().mods()[0].desc() == Some(~"test");
|
2012-01-18 18:51:04 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-02-17 16:52:27 -08:00
|
|
|
fn should_extract_top_mod_attributes() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"#[doc = \"test\"];");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().desc() == Some(~"test");
|
2012-01-18 18:51:04 -08:00
|
|
|
}
|
|
|
|
|
2012-02-24 14:22:13 -08:00
|
|
|
#[test]
|
2012-06-26 16:18:37 -07:00
|
|
|
fn should_extract_foreign_mod_attributes() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"#[doc = \"test\"] extern mod a { }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().nmods()[0].desc() == Some(~"test");
|
2012-02-24 14:22:13 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-06-26 16:18:37 -07:00
|
|
|
fn should_extract_foreign_fn_attributes() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"extern mod a { #[doc = \"test\"] fn a(); }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().nmods()[0].fns[0].desc() == Some(~"test");
|
2012-02-24 14:22:13 -08:00
|
|
|
}
|
|
|
|
|
2012-01-16 19:39:53 -08:00
|
|
|
#[test]
|
2012-02-17 16:52:27 -08:00
|
|
|
fn should_extract_fn_attributes() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"#[doc = \"test\"] fn a() -> int { }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().fns()[0].desc() == Some(~"test");
|
2012-01-16 16:05:59 -08:00
|
|
|
}
|
2012-01-18 22:24:29 -08:00
|
|
|
|
2012-01-25 18:23:21 -08:00
|
|
|
fn fold_enum(
|
2012-11-19 18:48:46 -08:00
|
|
|
fold: &fold::Fold<astsrv::Srv>,
|
2013-01-30 19:32:36 -08:00
|
|
|
doc: doc::EnumDoc
|
2012-09-18 16:48:40 -07:00
|
|
|
) -> doc::EnumDoc {
|
2012-02-26 23:47:27 -08:00
|
|
|
|
2012-01-25 18:23:21 -08:00
|
|
|
let srv = fold.ctxt;
|
2012-02-26 23:47:27 -08:00
|
|
|
let doc_id = doc.id();
|
2012-02-17 16:52:27 -08:00
|
|
|
let doc = fold::default_seq_fold_enum(fold, doc);
|
2012-01-25 18:23:21 -08:00
|
|
|
|
2013-01-25 16:57:39 -08:00
|
|
|
doc::EnumDoc {
|
2012-07-14 03:36:35 +10:00
|
|
|
variants: do par::map(doc.variants) |variant| {
|
2013-01-30 13:14:35 -08:00
|
|
|
let variant = copy *variant;
|
|
|
|
let desc = do astsrv::exec(srv) |ctxt, copy variant| {
|
2012-08-23 15:14:56 -07:00
|
|
|
match ctxt.ast_map.get(doc_id) {
|
2013-01-13 13:13:41 -08:00
|
|
|
ast_map::node_item(@ast::item {
|
2013-01-30 13:14:35 -08:00
|
|
|
node: ast::item_enum(ref enum_definition, _), _
|
2012-08-03 19:59:04 -07:00
|
|
|
}, _) => {
|
2012-01-25 18:23:21 -08:00
|
|
|
let ast_variant = option::get(
|
2012-10-19 11:37:00 -07:00
|
|
|
vec::find(enum_definition.variants, |v| {
|
2012-07-18 16:18:02 -07:00
|
|
|
to_str(v.node.name) == variant.name
|
2012-06-26 13:55:56 -07:00
|
|
|
}));
|
2012-01-25 18:23:21 -08:00
|
|
|
|
2013-01-30 13:14:35 -08:00
|
|
|
attr_parser::parse_desc(copy ast_variant.node.attrs)
|
2012-01-25 18:23:21 -08:00
|
|
|
}
|
2012-10-12 12:32:36 -07:00
|
|
|
_ => fail fmt!("Enum variant %s has id that's not bound \
|
2012-08-23 15:14:56 -07:00
|
|
|
to an enum item", variant.name)
|
2012-01-25 18:23:21 -08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-01-25 16:57:39 -08:00
|
|
|
doc::VariantDoc {
|
2012-09-04 13:29:32 -07:00
|
|
|
desc: desc,
|
|
|
|
.. variant
|
2012-01-25 18:23:21 -08:00
|
|
|
}
|
2012-09-04 13:29:32 -07:00
|
|
|
},
|
|
|
|
.. doc
|
2012-01-25 18:23:21 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-02-17 16:52:27 -08:00
|
|
|
fn should_extract_enum_docs() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"#[doc = \"b\"]\
|
2012-01-31 18:32:37 -08:00
|
|
|
enum a { v }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().enums()[0].desc() == Some(~"b");
|
2012-01-25 18:23:21 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-02-17 16:52:27 -08:00
|
|
|
fn should_extract_variant_docs() {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = test::mk_doc(~"enum a { #[doc = \"c\"] v }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().enums()[0].variants[0].desc == Some(~"c");
|
2012-01-25 18:23:21 -08:00
|
|
|
}
|
2012-01-26 21:39:20 -08:00
|
|
|
|
2012-07-03 16:30:42 -07:00
|
|
|
fn fold_trait(
|
2012-11-19 18:48:46 -08:00
|
|
|
fold: &fold::Fold<astsrv::Srv>,
|
2013-01-30 19:32:36 -08:00
|
|
|
doc: doc::TraitDoc
|
2012-09-18 16:48:40 -07:00
|
|
|
) -> doc::TraitDoc {
|
2012-01-30 16:25:39 -08:00
|
|
|
let srv = fold.ctxt;
|
2012-07-03 16:30:42 -07:00
|
|
|
let doc = fold::default_seq_fold_trait(fold, doc);
|
2012-01-30 16:25:39 -08:00
|
|
|
|
2013-01-25 16:57:39 -08:00
|
|
|
doc::TraitDoc {
|
2013-01-30 13:14:35 -08:00
|
|
|
methods: merge_method_attrs(srv, doc.id(), copy doc.methods),
|
2012-09-04 13:29:32 -07:00
|
|
|
.. doc
|
2012-01-30 16:25:39 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn merge_method_attrs(
|
2012-09-18 16:48:40 -07:00
|
|
|
srv: astsrv::Srv,
|
|
|
|
item_id: doc::AstId,
|
2013-01-30 19:32:36 -08:00
|
|
|
docs: ~[doc::MethodDoc]
|
2012-09-18 16:48:40 -07:00
|
|
|
) -> ~[doc::MethodDoc] {
|
2012-02-17 16:52:27 -08:00
|
|
|
|
2012-01-30 16:25:39 -08:00
|
|
|
// Create an assoc list from method name to attributes
|
2012-08-20 12:23:37 -07:00
|
|
|
let attrs: ~[(~str, Option<~str>)] = do astsrv::exec(srv) |ctxt| {
|
2012-08-06 12:34:08 -07:00
|
|
|
match ctxt.ast_map.get(item_id) {
|
2013-01-13 13:13:41 -08:00
|
|
|
ast_map::node_item(@ast::item {
|
2013-01-30 13:14:35 -08:00
|
|
|
node: ast::item_trait(_, _, ref methods), _
|
2012-08-03 19:59:04 -07:00
|
|
|
}, _) => {
|
2013-01-30 13:14:35 -08:00
|
|
|
vec::map(*methods, |method| {
|
|
|
|
match copy *method {
|
2012-08-03 19:59:04 -07:00
|
|
|
ast::required(ty_m) => {
|
2013-01-30 13:14:35 -08:00
|
|
|
(to_str(ty_m.ident),
|
|
|
|
attr_parser::parse_desc(copy ty_m.attrs))
|
2012-07-10 13:44:20 -07:00
|
|
|
}
|
2012-08-03 19:59:04 -07:00
|
|
|
ast::provided(m) => {
|
2013-01-30 13:14:35 -08:00
|
|
|
(to_str(m.ident), attr_parser::parse_desc(copy m.attrs))
|
2012-07-10 13:44:20 -07:00
|
|
|
}
|
|
|
|
}
|
2012-06-26 13:55:56 -07:00
|
|
|
})
|
2012-01-30 16:25:39 -08:00
|
|
|
}
|
2013-01-13 13:13:41 -08:00
|
|
|
ast_map::node_item(@ast::item {
|
2013-01-30 13:14:35 -08:00
|
|
|
node: ast::item_impl(_, _, _, ref methods), _
|
2012-08-03 19:59:04 -07:00
|
|
|
}, _) => {
|
2013-01-30 13:14:35 -08:00
|
|
|
vec::map(*methods, |method| {
|
2012-11-13 19:08:01 -08:00
|
|
|
(to_str(method.ident),
|
2013-01-30 13:14:35 -08:00
|
|
|
attr_parser::parse_desc(copy method.attrs))
|
2012-11-13 19:08:01 -08:00
|
|
|
})
|
2012-01-30 21:00:57 -08:00
|
|
|
}
|
2012-08-03 19:59:04 -07:00
|
|
|
_ => fail ~"unexpected item"
|
2012-01-30 16:25:39 -08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-06-30 16:19:07 -07:00
|
|
|
do vec::map2(docs, attrs) |doc, attrs| {
|
2012-07-16 22:32:59 +01:00
|
|
|
assert doc.name == attrs.first();
|
|
|
|
let desc = attrs.second();
|
2012-01-30 16:25:39 -08:00
|
|
|
|
2013-01-25 16:57:39 -08:00
|
|
|
doc::MethodDoc {
|
2012-09-04 13:29:32 -07:00
|
|
|
desc: desc,
|
2013-01-30 13:14:35 -08:00
|
|
|
.. copy *doc
|
2012-01-30 16:25:39 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-07-03 16:30:42 -07:00
|
|
|
fn should_extract_trait_docs() {
|
2012-07-31 10:27:51 -07:00
|
|
|
let doc = test::mk_doc(~"#[doc = \"whatever\"] trait i { fn a(); }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().traits()[0].desc() == Some(~"whatever");
|
2012-01-30 16:25:39 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-07-03 16:30:42 -07:00
|
|
|
fn should_extract_trait_method_docs() {
|
2012-01-31 18:32:37 -08:00
|
|
|
let doc = test::mk_doc(
|
2012-07-31 10:27:51 -07:00
|
|
|
~"trait i {\
|
2012-03-09 17:23:56 -08:00
|
|
|
#[doc = \"desc\"]\
|
2012-01-31 18:32:37 -08:00
|
|
|
fn f(a: bool) -> bool;\
|
|
|
|
}");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().traits()[0].methods[0].desc == Some(~"desc");
|
2012-01-30 21:00:57 -08:00
|
|
|
}
|
2012-01-31 17:05:40 -08:00
|
|
|
|
|
|
|
|
|
|
|
fn fold_impl(
|
2012-11-19 18:48:46 -08:00
|
|
|
fold: &fold::Fold<astsrv::Srv>,
|
2013-01-30 19:32:36 -08:00
|
|
|
doc: doc::ImplDoc
|
2012-09-18 16:48:40 -07:00
|
|
|
) -> doc::ImplDoc {
|
2012-01-31 17:05:40 -08:00
|
|
|
let srv = fold.ctxt;
|
|
|
|
let doc = fold::default_seq_fold_impl(fold, doc);
|
|
|
|
|
2013-01-25 16:57:39 -08:00
|
|
|
doc::ImplDoc {
|
2013-01-30 13:14:35 -08:00
|
|
|
methods: merge_method_attrs(srv, doc.id(), copy doc.methods),
|
2012-09-04 13:29:32 -07:00
|
|
|
.. doc
|
2012-01-31 17:05:40 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn should_extract_impl_docs() {
|
2012-01-31 18:32:37 -08:00
|
|
|
let doc = test::mk_doc(
|
2012-08-08 17:19:06 -07:00
|
|
|
~"#[doc = \"whatever\"] impl int { fn a() { } }");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().impls()[0].desc() == Some(~"whatever");
|
2012-01-31 17:05:40 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn should_extract_impl_method_docs() {
|
2012-01-31 18:32:37 -08:00
|
|
|
let doc = test::mk_doc(
|
2012-08-08 17:19:06 -07:00
|
|
|
~"impl int {\
|
2012-03-09 17:23:56 -08:00
|
|
|
#[doc = \"desc\"]\
|
2012-01-31 18:32:37 -08:00
|
|
|
fn f(a: bool) -> bool { }\
|
|
|
|
}");
|
2012-08-20 12:23:37 -07:00
|
|
|
assert doc.cratemod().impls()[0].methods[0].desc == Some(~"desc");
|
2012-01-31 17:05:40 -08:00
|
|
|
}
|
2012-01-31 18:32:37 -08:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
2012-12-29 17:38:20 -08:00
|
|
|
use astsrv;
|
2013-01-08 19:37:25 -08:00
|
|
|
use attr_pass::run;
|
2012-12-29 17:38:20 -08:00
|
|
|
use doc;
|
|
|
|
use extract;
|
|
|
|
|
2013-01-30 19:32:36 -08:00
|
|
|
pub fn mk_doc(source: ~str) -> doc::Doc {
|
2013-01-30 13:14:35 -08:00
|
|
|
do astsrv::from_str(copy source) |srv| {
|
2012-07-13 22:57:48 -07:00
|
|
|
let doc = extract::from_srv(srv, ~"");
|
2012-02-20 21:08:19 -08:00
|
|
|
run(srv, doc)
|
|
|
|
}
|
2012-01-31 18:32:37 -08:00
|
|
|
}
|
2012-03-07 16:48:57 -08:00
|
|
|
}
|