From c5830a954e3be1cc19f7ec4700599fcb0030b1fd Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 29 May 2014 09:58:09 -0700 Subject: [PATCH] doc: Fix a number of broken links cc #14515 --- src/doc/complement-cheatsheet.md | 37 ++++++++++++++++---------------- src/doc/complement-lang-faq.md | 6 +++--- src/doc/guide-unsafe.md | 9 ++++---- src/liballoc/lib.rs | 1 + src/libcore/lib.rs | 2 ++ src/libcore/result.rs | 4 ++-- src/librustdoc/html/format.rs | 14 ++++++++---- src/librustdoc/html/render.rs | 13 +++++++---- src/librustuv/homing.rs | 1 + 9 files changed, 52 insertions(+), 35 deletions(-) diff --git a/src/doc/complement-cheatsheet.md b/src/doc/complement-cheatsheet.md index 1c3352a829c..e2dae8c8b52 100644 --- a/src/doc/complement-cheatsheet.md +++ b/src/doc/complement-cheatsheet.md @@ -4,7 +4,7 @@ **Int to string** -Use [`ToStr`](../std/to_str/trait.ToStr.html). +Use [`ToStr`](std/to_str/trait.ToStr.html). ~~~ let x: int = 42; @@ -13,8 +13,8 @@ let y: String = x.to_str().to_string(); **String to int** -Use [`FromStr`](../std/from_str/trait.FromStr.html), and its helper function, -[`from_str`](../std/from_str/fn.from_str.html). +Use [`FromStr`](std/from_str/trait.FromStr.html), and its helper function, +[`from_str`](std/from_str/fn.from_str.html). ~~~ let x: Option = from_str("42"); @@ -35,8 +35,8 @@ let y: String = format!("{:X}", x); // uppercase hexadecimal **String to int, in non-base-10** -Use [`FromStrRadix`](../std/num/trait.FromStrRadix.html), and its helper -function, [`from_str_radix`](../std/num/fn.from_str_radix.html). +Use [`FromStrRadix`](std/num/trait.FromStrRadix.html), and its helper +function, [`from_str_radix`](std/num/fn.from_str_radix.html). ~~~ use std::num; @@ -48,7 +48,7 @@ let y: i64 = x.unwrap(); **Vector of Bytes to String** To return a Borrowed String Slice (&str) use the str helper function -[`from_utf8`](../std/str/fn.from_utf8.html). +[`from_utf8`](std/str/fn.from_utf8.html). ~~~ use std::str; @@ -58,7 +58,7 @@ let x: &str = str::from_utf8(bytes).unwrap(); ~~~ To return an Owned String use the str helper function -[`from_utf8_owned`](../std/str/fn.from_utf8_owned.html). +[`from_utf8_owned`](std/str/fn.from_utf8_owned.html). ~~~ use std::str; @@ -68,8 +68,8 @@ let x: Option = let y: String = x.unwrap(); ~~~ -To return a [`MaybeOwned`](../std/str/enum.MaybeOwned.html) use the str helper -function [`from_utf8_lossy`](../std/str/fn.from_utf8_owned.html). +To return a [`MaybeOwned`](std/str/type.MaybeOwned.html) use the str helper +function [`from_utf8_lossy`](std/str/fn.from_utf8_owned.html). This function also replaces non-valid utf-8 sequences with U+FFFD replacement character. @@ -85,11 +85,11 @@ let y = str::from_utf8_lossy(x); ## How do I read from a file? Use -[`File::open`](../std/io/fs/struct.File.html#method.open) +[`File::open`](std/io/fs/struct.File.html#method.open) to create a -[`File`](../std/io/fs/struct.File.html) +[`File`](std/io/fs/struct.File.html) struct, which implements the -[`Reader`](../std/io/trait.Reader.html) +[`Reader`](std/io/trait.Reader.html) trait. ~~~ {.ignore} @@ -103,7 +103,8 @@ let reader : File = File::open(&path).unwrap_or_else(on_error); ## How do I iterate over the lines in a file? -Use the [`lines`](../std/io/trait.Buffer.html#method.lines) method on a [`BufferedReader`](../std/io/buffered/struct.BufferedReader.html). +Use the [`lines`](std/io/trait.Buffer.html#method.lines) method on a +[`BufferedReader`](std/io/struct.BufferedReader.html). ~~~ use std::io::BufferedReader; @@ -121,7 +122,7 @@ for line in reader.lines() { ## How do I search for a substring? -Use the [`find_str`](../std/str/trait.StrSlice.html#tymethod.find_str) method. +Use the [`find_str`](std/str/trait.StrSlice.html#tymethod.find_str) method. ~~~ let str = "Hello, this is some random string"; @@ -132,7 +133,7 @@ let index: Option = str.find_str("rand"); ## How do I get the length of a vector? -The [`Container`](../std/container/trait.Container.html) trait provides the `len` method. +The [`Container`](std/container/trait.Container.html) trait provides the `len` method. ~~~ let u: Vec = vec![0, 1, 2]; @@ -144,7 +145,7 @@ println!("u: {}, v: {}, w: {}", u.len(), v.len(), w.len()); // 3, 4, 5 ## How do I iterate over a vector? -Use the [`iter`](../std/vec/trait.ImmutableVector.html#tymethod.iter) method. +Use the [`iter`](std/slice/trait.ImmutableVector.html#tymethod.iter) method. ~~~ let values: Vec = vec![1, 2, 3, 4, 5]; @@ -153,9 +154,9 @@ for value in values.iter() { // value: &int } ~~~ -(See also [`mut_iter`](../std/vec/trait.MutableVector.html#tymethod.mut_iter) +(See also [`mut_iter`](std/slice/trait.MutableVector.html#tymethod.mut_iter) which yields `&mut int` and -[`move_iter`](../std/vec/trait.OwnedVector.html#tymethod.move_iter) which yields +[`move_iter`](std/slice/trait.OwnedVector.html#tymethod.move_iter) which yields `int` while consuming the `values` vector.) # Type system diff --git a/src/doc/complement-lang-faq.md b/src/doc/complement-lang-faq.md index a357f9ef195..c03c72ca35f 100644 --- a/src/doc/complement-lang-faq.md +++ b/src/doc/complement-lang-faq.md @@ -21,7 +21,7 @@ Some examples that demonstrate different aspects of the language: * The extra library's [json] module. Enums and pattern matching [sprocketnes]: https://github.com/pcwalton/sprocketnes -[hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash.rs +[hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash/mod.rs [HashMap]: https://github.com/mozilla/rust/blob/master/src/libcollections/hashmap.rs [json]: https://github.com/mozilla/rust/blob/master/src/libserialize/json.rs @@ -149,6 +149,6 @@ example we were setting RUST_LOG to the name of the hello crate. Multiple paths can be combined to control the exact logging you want to see. For example, when debugging linking in the compiler you might set `RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath` -For a full description see [the language reference][1]. +For a full description see [the logging crate][1]. -[1]:http://doc.rust-lang.org/doc/master/rust.html#logging-system +[1]:log/index.html diff --git a/src/doc/guide-unsafe.md b/src/doc/guide-unsafe.md index 717902e01d5..a85e889ed48 100644 --- a/src/doc/guide-unsafe.md +++ b/src/doc/guide-unsafe.md @@ -499,9 +499,9 @@ shouldn't get triggered. The second of these two functions, `eh_personality`, is used by the failure mechanisms of the compiler. This is often mapped to GCC's personality function -(see the [libstd implementation](../std/rt/unwind/) for more information), but -crates which do not trigger failure can be assured that this function is never -called. +(see the [libstd implementation](std/rt/unwind/index.html) for more +information), but crates which do not trigger failure can be assured that this +function is never called. ## Using libcore @@ -511,7 +511,8 @@ called. With the above techniques, we've got a bare-metal executable running some Rust code. There is a good deal of functionality provided by the standard library, however, that is necessary to be productive in Rust. If the standard library is -not sufficient, then [libcore](../core/) is designed to be used instead. +not sufficient, then [libcore](../core/index.html) is designed to be used +instead. The core library has very few dependencies and is much more portable than the standard library itself. Additionally, the core library has most of the diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 7e250e130fa..511983da4f7 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -97,6 +97,7 @@ pub mod arc; pub mod rc; #[cfg(not(test))] +#[doc(hidden)] mod std { pub use core::fmt; pub use core::option; diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 2ff2dca0c86..6aa07415e9c 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -134,10 +134,12 @@ pub mod fmt; // crate. mod should_not_exist; +#[doc(hidden)] mod core { pub use failure; } +#[doc(hidden)] mod std { pub use clone; pub use cmp; diff --git a/src/libcore/result.rs b/src/libcore/result.rs index f3ec95d9582..0762c7458d9 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -234,8 +234,8 @@ //! similar and complementary: they are often employed to indicate a //! lack of a return value; and they are trivially converted between //! each other, so `Result`s are often handled by first converting to -//! `Option` with the [`ok`](enum.Result.html#method.ok) and -//! [`err`](enum.Result.html#method.ok) methods. +//! `Option` with the [`ok`](type.Result.html#method.ok) and +//! [`err`](type.Result.html#method.ok) methods. //! //! Whereas `Option` only indicates the lack of a value, `Result` is //! specifically for error reporting, and carries with it an error diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 50f25a0f8f1..54900ab0ab8 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -278,18 +278,24 @@ fn primitive_link(f: &mut fmt::Formatter, needs_termination = true; } Some(&cnum) => { + let path = m.paths.get(&ast::DefId { + krate: cnum, + node: ast::CRATE_NODE_ID, + }); let loc = match *m.extern_locations.get(&cnum) { render::Remote(ref s) => Some(s.to_string()), render::Local => { let loc = current_location_key.get().unwrap(); - Some(("../".repeat(loc.len())).to_string()) + Some("../".repeat(loc.len())) } render::Unknown => None, }; match loc { - Some(s) => { - try!(write!(f, "", - s, prim.to_url_str())); + Some(root) => { + try!(write!(f, "", + root, + path.ref0().as_slice().head().unwrap(), + prim.to_url_str())); needs_termination = true; } None => {} diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index d82a83cbd39..fa93a026107 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1380,8 +1380,13 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, if s.len() == 0 { return Ok(()); } try!(write!(f, " = ")); if s.contains("\n") { - write!(f, "[definition]", - item.href()) + match item.href() { + Some(url) => { + write!(f, "[definition]", + url) + } + None => Ok(()), + } } else { write!(f, "{}", s.as_slice()) } @@ -1547,8 +1552,8 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, } try!(write!(w, "")); try!(write!(w, r#""#, + src="{root_path}/implementors/{path}/{ty}.{name}.js"> + "#, root_path = Vec::from_elem(cx.current.len(), "..").connect("/"), path = if ast_util::is_local(it.def_id) { cx.current.connect("/") diff --git a/src/librustuv/homing.rs b/src/librustuv/homing.rs index 5bb9c70f047..4f565de6791 100644 --- a/src/librustuv/homing.rs +++ b/src/librustuv/homing.rs @@ -82,6 +82,7 @@ pub fn local_id() -> uint { } } +#[doc(hidden)] pub trait HomingIO { fn home<'r>(&'r mut self) -> &'r mut HomeHandle;