2018-04-15 01:27:57 +02:00
|
|
|
//! Documentation generation for rustbuilder.
|
2016-05-03 00:16:15 +02:00
|
|
|
//!
|
|
|
|
//! This module implements generation for all bits and pieces of documentation
|
|
|
|
//! for the Rust project. This notably includes suites like the rust book, the
|
2017-12-02 03:29:12 +01:00
|
|
|
//! nomicon, rust by example, standalone documentation, etc.
|
2016-05-03 00:16:15 +02:00
|
|
|
//!
|
|
|
|
//! Everything here is basically just a shim around calling either `rustbook` or
|
|
|
|
//! `rustdoc`.
|
|
|
|
|
2018-03-22 15:57:28 +01:00
|
|
|
use std::collections::HashSet;
|
2018-11-16 22:22:06 +01:00
|
|
|
use std::fs;
|
2017-03-02 00:34:54 +01:00
|
|
|
use std::io;
|
2017-07-14 02:48:44 +02:00
|
|
|
use std::path::{PathBuf, Path};
|
2016-02-16 19:26:43 +01:00
|
|
|
|
2018-12-07 13:21:05 +01:00
|
|
|
use crate::Mode;
|
2019-05-09 18:03:13 +02:00
|
|
|
use build_helper::{t, up_to_date};
|
2016-02-16 19:26:43 +01:00
|
|
|
|
2018-12-07 13:21:05 +01:00
|
|
|
use crate::util::symlink_dir;
|
|
|
|
use crate::builder::{Builder, Compiler, RunConfig, ShouldRun, Step};
|
|
|
|
use crate::tool::{self, prepare_tool_cargo, Tool, SourceType};
|
|
|
|
use crate::compile;
|
|
|
|
use crate::cache::{INTERNER, Interned};
|
|
|
|
use crate::config::Config;
|
2017-07-05 18:46:41 +02:00
|
|
|
|
2017-07-05 14:41:27 +02:00
|
|
|
macro_rules! book {
|
2019-07-08 23:52:07 +02:00
|
|
|
($($name:ident, $path:expr, $book_name:expr;)+) => {
|
2017-07-05 14:41:27 +02:00
|
|
|
$(
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct $name {
|
|
|
|
target: Interned<String>,
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for $name {
|
2017-07-05 14:41:27 +02:00
|
|
|
type Output = ();
|
|
|
|
const DEFAULT: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:24:11 +02:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.path($path).default_condition(builder.config.docs)
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure($name {
|
|
|
|
target: run.target,
|
2017-07-05 14:41:27 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2019-06-07 17:39:28 +02:00
|
|
|
builder.ensure(RustbookSrc {
|
2017-07-05 14:41:27 +02:00
|
|
|
target: self.target,
|
2017-07-14 02:48:44 +02:00
|
|
|
name: INTERNER.intern_str($book_name),
|
2019-06-07 17:39:28 +02:00
|
|
|
src: doc_src(builder),
|
2017-07-05 14:41:27 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)+
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-10 20:37:51 +01:00
|
|
|
// NOTE: When adding a book here, make sure to ALSO build the book by
|
|
|
|
// adding a build step in `src/bootstrap/builder.rs`!
|
2017-07-05 14:41:27 +02:00
|
|
|
book!(
|
2019-07-08 23:52:07 +02:00
|
|
|
EditionGuide, "src/doc/edition-guide", "edition-guide";
|
|
|
|
EmbeddedBook, "src/doc/embedded-book", "embedded-book";
|
|
|
|
Nomicon, "src/doc/nomicon", "nomicon";
|
|
|
|
Reference, "src/doc/reference", "reference";
|
|
|
|
RustByExample, "src/doc/rust-by-example", "rust-by-example";
|
|
|
|
RustcBook, "src/doc/rustc", "rustc";
|
|
|
|
RustdocBook, "src/doc/rustdoc", "rustdoc";
|
2017-07-05 14:41:27 +02:00
|
|
|
);
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2019-06-07 17:39:28 +02:00
|
|
|
fn doc_src(builder: &Builder<'_>) -> Interned<PathBuf> {
|
|
|
|
INTERNER.intern_path(builder.src.join("src/doc"))
|
2017-06-12 21:35:47 +02:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct UnstableBook {
|
|
|
|
target: Interned<String>,
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for UnstableBook {
|
2017-07-05 14:41:27 +02:00
|
|
|
type Output = ();
|
|
|
|
const DEFAULT: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:24:11 +02:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.path("src/doc/unstable-book").default_condition(builder.config.docs)
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure(UnstableBook {
|
|
|
|
target: run.target,
|
2017-07-05 14:41:27 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-07-05 14:41:27 +02:00
|
|
|
builder.ensure(UnstableBookGen {
|
|
|
|
target: self.target,
|
|
|
|
});
|
|
|
|
builder.ensure(RustbookSrc {
|
|
|
|
target: self.target,
|
2017-07-14 02:48:44 +02:00
|
|
|
name: INTERNER.intern_str("unstable-book"),
|
2018-04-15 01:27:57 +02:00
|
|
|
src: builder.md_doc_out(self.target),
|
2017-07-05 14:41:27 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
2017-07-05 01:53:53 +02:00
|
|
|
|
2017-11-01 20:21:55 +01:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct CargoBook {
|
|
|
|
target: Interned<String>,
|
|
|
|
name: Interned<String>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Step for CargoBook {
|
|
|
|
type Output = ();
|
|
|
|
const DEFAULT: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-11-01 20:21:55 +01:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.path("src/tools/cargo/src/doc/book").default_condition(builder.config.docs)
|
2017-11-01 20:21:55 +01:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-11-01 20:21:55 +01:00
|
|
|
run.builder.ensure(CargoBook {
|
|
|
|
target: run.target,
|
|
|
|
name: INTERNER.intern_str("cargo"),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-11-01 20:21:55 +01:00
|
|
|
let target = self.target;
|
|
|
|
let name = self.name;
|
2018-04-15 01:27:57 +02:00
|
|
|
let src = builder.src.join("src/tools/cargo/src/doc");
|
2017-11-01 20:24:35 +01:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
let out = builder.doc_out(target);
|
2017-11-01 20:21:55 +01:00
|
|
|
t!(fs::create_dir_all(&out));
|
|
|
|
|
|
|
|
let out = out.join(name);
|
2017-11-01 20:24:35 +01:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Cargo Book ({}) - {}", target, name));
|
2017-11-01 20:24:35 +01:00
|
|
|
|
2017-11-01 20:21:55 +01:00
|
|
|
let _ = fs::remove_dir_all(&out);
|
2017-11-01 20:24:35 +01:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.run(builder.tool_cmd(Tool::Rustbook)
|
2017-11-01 20:21:55 +01:00
|
|
|
.arg("build")
|
|
|
|
.arg(&src)
|
|
|
|
.arg("-d")
|
|
|
|
.arg(out));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
2017-07-19 02:03:38 +02:00
|
|
|
struct RustbookSrc {
|
2017-07-14 02:48:44 +02:00
|
|
|
target: Interned<String>,
|
|
|
|
name: Interned<String>,
|
|
|
|
src: Interned<PathBuf>,
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2017-07-05 01:53:53 +02:00
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for RustbookSrc {
|
2017-07-05 03:41:43 +02:00
|
|
|
type Output = ();
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-19 02:03:38 +02:00
|
|
|
run.never()
|
2017-07-14 14:30:16 +02:00
|
|
|
}
|
|
|
|
|
2017-07-05 03:41:43 +02:00
|
|
|
/// Invoke `rustbook` for `target` for the doc book `name` from the `src` path.
|
|
|
|
///
|
|
|
|
/// This will not actually generate any documentation if the documentation has
|
|
|
|
/// already been generated.
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let target = self.target;
|
|
|
|
let name = self.name;
|
|
|
|
let src = self.src;
|
2018-04-15 01:27:57 +02:00
|
|
|
let out = builder.doc_out(target);
|
2017-07-05 03:41:43 +02:00
|
|
|
t!(fs::create_dir_all(&out));
|
|
|
|
|
|
|
|
let out = out.join(name);
|
|
|
|
let src = src.join(name);
|
|
|
|
let index = out.join("index.html");
|
2017-07-05 14:41:27 +02:00
|
|
|
let rustbook = builder.tool_exe(Tool::Rustbook);
|
2018-03-27 16:06:47 +02:00
|
|
|
let mut rustbook_cmd = builder.tool_cmd(Tool::Rustbook);
|
2017-07-05 03:41:43 +02:00
|
|
|
if up_to_date(&src, &index) && up_to_date(&rustbook, &index) {
|
|
|
|
return
|
|
|
|
}
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Rustbook ({}) - {}", target, name));
|
2017-07-05 03:41:43 +02:00
|
|
|
let _ = fs::remove_dir_all(&out);
|
2019-01-10 20:37:51 +01:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.run(rustbook_cmd
|
2017-07-05 03:41:43 +02:00
|
|
|
.arg("build")
|
|
|
|
.arg(&src)
|
|
|
|
.arg("-d")
|
2019-07-08 23:52:07 +02:00
|
|
|
.arg(out));
|
2016-02-16 19:26:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct TheBook {
|
2017-07-26 01:56:06 +02:00
|
|
|
compiler: Compiler,
|
2017-07-14 02:48:44 +02:00
|
|
|
target: Interned<String>,
|
|
|
|
name: &'static str,
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for TheBook {
|
2017-07-05 03:41:43 +02:00
|
|
|
type Output = ();
|
2017-07-14 06:37:33 +02:00
|
|
|
const DEFAULT: bool = true;
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:24:11 +02:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.path("src/doc/book").default_condition(builder.config.docs)
|
2017-07-13 02:52:31 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure(TheBook {
|
2018-04-15 01:27:57 +02:00
|
|
|
compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build),
|
2017-07-21 01:51:07 +02:00
|
|
|
target: run.target,
|
2017-07-13 02:52:31 +02:00
|
|
|
name: "book",
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-02-08 14:53:55 +01:00
|
|
|
/// Builds the book and associated stuff.
|
2017-07-05 03:41:43 +02:00
|
|
|
///
|
|
|
|
/// We need to build:
|
|
|
|
///
|
|
|
|
/// * Book (first edition)
|
|
|
|
/// * Book (second edition)
|
2017-11-15 03:57:03 +01:00
|
|
|
/// * Version info and CSS
|
2017-07-05 03:41:43 +02:00
|
|
|
/// * Index page
|
|
|
|
/// * Redirect pages
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-11-15 03:57:03 +01:00
|
|
|
let compiler = self.compiler;
|
2017-07-05 03:41:43 +02:00
|
|
|
let target = self.target;
|
|
|
|
let name = self.name;
|
2018-11-20 20:57:56 +01:00
|
|
|
|
|
|
|
// build book
|
2019-06-07 17:39:28 +02:00
|
|
|
builder.ensure(RustbookSrc {
|
2017-08-07 07:54:09 +02:00
|
|
|
target,
|
2018-11-20 20:57:56 +01:00
|
|
|
name: INTERNER.intern_string(name.to_string()),
|
2019-06-07 17:39:28 +02:00
|
|
|
src: doc_src(builder),
|
2017-07-05 14:41:27 +02:00
|
|
|
});
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-11-20 20:57:56 +01:00
|
|
|
// building older edition redirects
|
|
|
|
|
|
|
|
let source_name = format!("{}/first-edition", name);
|
2019-06-07 17:39:28 +02:00
|
|
|
builder.ensure(RustbookSrc {
|
2017-08-07 07:54:09 +02:00
|
|
|
target,
|
2018-11-20 20:57:56 +01:00
|
|
|
name: INTERNER.intern_string(source_name),
|
2019-06-07 17:39:28 +02:00
|
|
|
src: doc_src(builder),
|
2017-07-05 14:41:27 +02:00
|
|
|
});
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-11-20 20:57:56 +01:00
|
|
|
let source_name = format!("{}/second-edition", name);
|
2019-06-07 17:39:28 +02:00
|
|
|
builder.ensure(RustbookSrc {
|
2018-05-21 21:31:12 +02:00
|
|
|
target,
|
2018-11-20 20:57:56 +01:00
|
|
|
name: INTERNER.intern_string(source_name),
|
2019-06-07 17:39:28 +02:00
|
|
|
src: doc_src(builder),
|
2018-11-20 20:57:56 +01:00
|
|
|
});
|
|
|
|
|
|
|
|
let source_name = format!("{}/2018-edition", name);
|
2019-06-07 17:39:28 +02:00
|
|
|
builder.ensure(RustbookSrc {
|
2018-11-20 20:57:56 +01:00
|
|
|
target,
|
|
|
|
name: INTERNER.intern_string(source_name),
|
2019-06-07 17:39:28 +02:00
|
|
|
src: doc_src(builder),
|
2018-05-21 21:31:12 +02:00
|
|
|
});
|
|
|
|
|
2017-11-15 03:57:03 +01:00
|
|
|
// build the version info page and CSS
|
|
|
|
builder.ensure(Standalone {
|
|
|
|
compiler,
|
|
|
|
target,
|
|
|
|
});
|
|
|
|
|
2017-07-05 03:41:43 +02:00
|
|
|
// build the redirect pages
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Documenting book redirect pages ({})", target));
|
|
|
|
for file in t!(fs::read_dir(builder.src.join("src/doc/book/redirects"))) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let file = t!(file);
|
|
|
|
let path = file.path();
|
|
|
|
let path = path.to_str().unwrap();
|
|
|
|
|
2017-11-15 03:57:03 +01:00
|
|
|
invoke_rustdoc(builder, compiler, target, path);
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2017-03-07 22:07:55 +01:00
|
|
|
}
|
2017-03-07 21:31:41 +01:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn invoke_rustdoc(
|
|
|
|
builder: &Builder<'_>,
|
|
|
|
compiler: Compiler,
|
|
|
|
target: Interned<String>,
|
|
|
|
markdown: &str,
|
|
|
|
) {
|
2018-04-15 01:27:57 +02:00
|
|
|
let out = builder.doc_out(target);
|
2017-03-07 21:31:41 +01:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
let path = builder.src.join("src/doc").join(markdown);
|
2017-03-07 21:31:41 +01:00
|
|
|
|
2019-03-14 23:52:56 +01:00
|
|
|
let header = builder.src.join("src/doc/redirect.inc");
|
2018-04-15 01:27:57 +02:00
|
|
|
let footer = builder.src.join("src/doc/footer.inc");
|
2017-03-07 21:31:41 +01:00
|
|
|
let version_info = out.join("version_info.html");
|
|
|
|
|
2019-03-03 17:50:56 +01:00
|
|
|
let mut cmd = builder.rustdoc_cmd(compiler);
|
2017-03-07 21:31:41 +01:00
|
|
|
|
|
|
|
let out = out.join("book");
|
|
|
|
|
|
|
|
cmd.arg("--html-after-content").arg(&footer)
|
|
|
|
.arg("--html-before-content").arg(&version_info)
|
2019-03-14 23:52:56 +01:00
|
|
|
.arg("--html-in-header").arg(&header)
|
2018-03-02 19:52:13 +01:00
|
|
|
.arg("--markdown-no-toc")
|
2019-03-01 17:03:15 +01:00
|
|
|
.arg("--markdown-playground-url").arg("https://play.rust-lang.org/")
|
|
|
|
.arg("-o").arg(&out).arg(&path)
|
|
|
|
.arg("--markdown-css").arg("../rust.css");
|
2017-03-07 21:31:41 +01:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.run(&mut cmd);
|
2017-03-07 20:49:50 +01:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct Standalone {
|
2017-07-26 01:56:06 +02:00
|
|
|
compiler: Compiler,
|
2017-07-14 02:48:44 +02:00
|
|
|
target: Interned<String>,
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2016-02-16 19:26:43 +01:00
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for Standalone {
|
2017-07-05 03:41:43 +02:00
|
|
|
type Output = ();
|
2017-07-05 14:41:27 +02:00
|
|
|
const DEFAULT: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:51:07 +02:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.path("src/doc").default_condition(builder.config.docs)
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure(Standalone {
|
2018-04-15 01:27:57 +02:00
|
|
|
compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build),
|
2017-07-21 01:51:07 +02:00
|
|
|
target: run.target,
|
2017-07-05 14:41:27 +02:00
|
|
|
});
|
|
|
|
}
|
2017-07-05 03:41:43 +02:00
|
|
|
|
|
|
|
/// Generates all standalone documentation as compiled by the rustdoc in `stage`
|
|
|
|
/// for the `target` into `out`.
|
|
|
|
///
|
|
|
|
/// This will list all of `src/doc` looking for markdown files and appropriately
|
|
|
|
/// perform transformations like substituting `VERSION`, `SHORT_HASH`, and
|
2017-08-11 20:34:14 +02:00
|
|
|
/// `STAMP` along with providing the various header/footer HTML we've customized.
|
2017-07-05 03:41:43 +02:00
|
|
|
///
|
|
|
|
/// In the end, this is just a glorified wrapper around rustdoc!
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let target = self.target;
|
2017-07-26 01:56:06 +02:00
|
|
|
let compiler = self.compiler;
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Documenting standalone ({})", target));
|
|
|
|
let out = builder.doc_out(target);
|
2017-07-05 03:41:43 +02:00
|
|
|
t!(fs::create_dir_all(&out));
|
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
let favicon = builder.src.join("src/doc/favicon.inc");
|
|
|
|
let footer = builder.src.join("src/doc/footer.inc");
|
|
|
|
let full_toc = builder.src.join("src/doc/full-toc.inc");
|
|
|
|
t!(fs::copy(builder.src.join("src/doc/rust.css"), out.join("rust.css")));
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
let version_input = builder.src.join("src/doc/version_info.html.template");
|
2017-07-05 03:41:43 +02:00
|
|
|
let version_info = out.join("version_info.html");
|
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
if !builder.config.dry_run && !up_to_date(&version_input, &version_info) {
|
2018-11-16 22:22:06 +01:00
|
|
|
let info = t!(fs::read_to_string(&version_input))
|
|
|
|
.replace("VERSION", &builder.rust_release())
|
|
|
|
.replace("SHORT_HASH", builder.rust_info.sha_short().unwrap_or(""))
|
|
|
|
.replace("STAMP", builder.rust_info.sha().unwrap_or(""));
|
|
|
|
t!(fs::write(&version_info, &info));
|
2016-02-16 19:26:43 +01:00
|
|
|
}
|
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
for file in t!(fs::read_dir(builder.src.join("src/doc"))) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let file = t!(file);
|
|
|
|
let path = file.path();
|
|
|
|
let filename = path.file_name().unwrap().to_str().unwrap();
|
|
|
|
if !filename.ends_with(".md") || filename == "README.md" {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
let html = out.join(filename).with_extension("html");
|
2019-03-03 17:50:56 +01:00
|
|
|
let rustdoc = builder.rustdoc(compiler);
|
2017-07-05 03:41:43 +02:00
|
|
|
if up_to_date(&path, &html) &&
|
|
|
|
up_to_date(&footer, &html) &&
|
|
|
|
up_to_date(&favicon, &html) &&
|
|
|
|
up_to_date(&full_toc, &html) &&
|
2019-08-24 23:45:47 +02:00
|
|
|
(builder.config.dry_run || up_to_date(&version_info, &html)) &&
|
2018-04-15 01:27:57 +02:00
|
|
|
(builder.config.dry_run || up_to_date(&rustdoc, &html)) {
|
2017-07-05 03:41:43 +02:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2019-03-03 17:50:56 +01:00
|
|
|
let mut cmd = builder.rustdoc_cmd(compiler);
|
2017-07-05 03:41:43 +02:00
|
|
|
cmd.arg("--html-after-content").arg(&footer)
|
|
|
|
.arg("--html-before-content").arg(&version_info)
|
|
|
|
.arg("--html-in-header").arg(&favicon)
|
2018-09-29 16:40:37 +02:00
|
|
|
.arg("--markdown-no-toc")
|
2018-09-25 23:20:33 +02:00
|
|
|
.arg("--index-page").arg(&builder.src.join("src/doc/index.md"))
|
2019-03-01 17:03:15 +01:00
|
|
|
.arg("--markdown-playground-url").arg("https://play.rust-lang.org/")
|
2017-07-05 03:41:43 +02:00
|
|
|
.arg("-o").arg(&out)
|
|
|
|
.arg(&path);
|
|
|
|
|
|
|
|
if filename == "not_found.md" {
|
2018-09-29 16:40:37 +02:00
|
|
|
cmd.arg("--markdown-css")
|
2017-07-05 03:41:43 +02:00
|
|
|
.arg("https://doc.rust-lang.org/rust.css");
|
|
|
|
} else {
|
|
|
|
cmd.arg("--markdown-css").arg("rust.css");
|
|
|
|
}
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.run(&mut cmd);
|
2016-02-16 19:26:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-08 07:36:21 +01:00
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct Std {
|
2018-01-12 23:40:00 +01:00
|
|
|
pub stage: u32,
|
|
|
|
pub target: Interned<String>,
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for Std {
|
2017-07-05 03:41:43 +02:00
|
|
|
type Output = ();
|
2017-07-05 14:41:27 +02:00
|
|
|
const DEFAULT: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:24:11 +02:00
|
|
|
let builder = run.builder;
|
2019-08-27 17:32:21 +02:00
|
|
|
run.all_krates("test").default_condition(builder.config.docs)
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure(Std {
|
|
|
|
stage: run.builder.top_stage,
|
|
|
|
target: run.target
|
2017-07-21 01:24:11 +02:00
|
|
|
});
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
2017-07-05 03:41:43 +02:00
|
|
|
|
|
|
|
/// Compile all standard library documentation.
|
|
|
|
///
|
|
|
|
/// This will generate all documentation for the standard library and its
|
|
|
|
/// dependencies. This is largely just a wrapper around `cargo doc`.
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let stage = self.stage;
|
|
|
|
let target = self.target;
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Documenting stage{} std ({})", stage, target));
|
|
|
|
let out = builder.doc_out(target);
|
2017-07-05 03:41:43 +02:00
|
|
|
t!(fs::create_dir_all(&out));
|
2019-05-28 19:00:53 +02:00
|
|
|
let compiler = builder.compiler_for(stage, builder.config.build, target);
|
2017-07-05 14:41:27 +02:00
|
|
|
|
|
|
|
builder.ensure(compile::Std { compiler, target });
|
2018-05-19 22:04:41 +02:00
|
|
|
let out_dir = builder.stage_out(compiler, Mode::Std)
|
2017-07-05 03:41:43 +02:00
|
|
|
.join(target).join("doc");
|
|
|
|
|
|
|
|
// Here what we're doing is creating a *symlink* (directory junction on
|
|
|
|
// Windows) to the final output location. This is not done as an
|
|
|
|
// optimization but rather for correctness. We've got three trees of
|
|
|
|
// documentation, one for std, one for test, and one for rustc. It's then
|
|
|
|
// our job to merge them all together.
|
|
|
|
//
|
|
|
|
// Unfortunately rustbuild doesn't know nearly as well how to merge doc
|
|
|
|
// trees as rustdoc does itself, so instead of actually having three
|
|
|
|
// separate trees we just have rustdoc output to the same location across
|
|
|
|
// all of them.
|
|
|
|
//
|
|
|
|
// This way rustdoc generates output directly into the output, and rustdoc
|
|
|
|
// will also directly handle merging.
|
2018-04-15 01:27:57 +02:00
|
|
|
let my_out = builder.crate_doc_out(target);
|
|
|
|
t!(symlink_dir_force(&builder.config, &my_out, &out_dir));
|
2018-09-29 16:40:37 +02:00
|
|
|
t!(fs::copy(builder.src.join("src/doc/rust.css"), out.join("rust.css")));
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-09-25 23:20:33 +02:00
|
|
|
let run_cargo_rustdoc_for = |package: &str| {
|
|
|
|
let mut cargo = builder.cargo(compiler, Mode::Std, target, "rustdoc");
|
|
|
|
compile::std_cargo(builder, &compiler, target, &mut cargo);
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-09-25 23:20:33 +02:00
|
|
|
// Keep a whitelist so we do not build internal stdlib crates, these will be
|
|
|
|
// build by the rustc step later if enabled.
|
|
|
|
cargo.arg("-Z").arg("unstable-options")
|
|
|
|
.arg("-p").arg(package);
|
2018-03-20 03:06:38 +01:00
|
|
|
// Create all crate output directories first to make sure rustdoc uses
|
|
|
|
// relative links.
|
|
|
|
// FIXME: Cargo should probably do this itself.
|
2018-09-25 23:20:33 +02:00
|
|
|
t!(fs::create_dir_all(out_dir.join(package)));
|
|
|
|
cargo.arg("--")
|
2018-09-29 16:40:37 +02:00
|
|
|
.arg("--markdown-css").arg("rust.css")
|
|
|
|
.arg("--markdown-no-toc")
|
2018-12-12 00:33:00 +01:00
|
|
|
.arg("--generate-redirect-pages")
|
2019-03-01 17:03:15 +01:00
|
|
|
.arg("--resource-suffix").arg(crate::channel::CFG_RELEASE_NUM)
|
2018-09-29 16:40:37 +02:00
|
|
|
.arg("--index-page").arg(&builder.src.join("src/doc/index.md"));
|
2017-01-05 23:26:04 +01:00
|
|
|
|
2019-09-09 19:17:38 +02:00
|
|
|
builder.run(&mut cargo.into());
|
2018-09-25 23:20:33 +02:00
|
|
|
};
|
bootstrap: Merge the libtest build step with libstd
Since its inception rustbuild has always worked in three stages: one for
libstd, one for libtest, and one for rustc. These three stages were
architected around crates.io dependencies, where rustc wants to depend
on crates.io crates but said crates don't explicitly depend on libstd,
requiring a sysroot assembly step in the middle. This same logic was
applied for libtest where libtest wants to depend on crates.io crates
(`getopts`) but `getopts` didn't say that it depended on std, so it
needed `std` built ahead of time.
Lots of time has passed since the inception of rustbuild, however,
and we've since gotten to the point where even `std` itself is depending
on crates.io crates (albeit with some wonky configuration). This
commit applies the same logic to the two dependencies that the `test`
crate pulls in from crates.io, `getopts` and `unicode-width`. Over the
many years since rustbuild's inception `unicode-width` was the only
dependency picked up by the `test` crate, so the extra configuration
necessary to get crates building in this crate graph is unlikely to be
too much of a burden on developers.
After this patch it means that there are now only two build phasese of
rustbuild, one for libstd and one for rustc. The libtest/libproc_macro
build phase is all lumped into one now with `std`.
This was originally motivated by rust-lang/cargo#7216 where Cargo was
having to deal with synthesizing dependency edges but this commit makes
them explicit in this repository.
2019-08-16 17:29:08 +02:00
|
|
|
for krate in &["alloc", "core", "std", "proc_macro", "test"] {
|
2018-09-25 23:20:33 +02:00
|
|
|
run_cargo_rustdoc_for(krate);
|
2017-01-08 20:37:52 +01:00
|
|
|
}
|
2019-09-19 16:48:04 +02:00
|
|
|
builder.cp_r(&my_out, &out);
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2016-03-08 07:36:21 +01:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct Rustc {
|
2017-07-05 03:41:43 +02:00
|
|
|
stage: u32,
|
2017-07-14 02:48:44 +02:00
|
|
|
target: Interned<String>,
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for Rustc {
|
2017-07-05 03:41:43 +02:00
|
|
|
type Output = ();
|
2017-07-05 14:41:27 +02:00
|
|
|
const DEFAULT: bool = true;
|
|
|
|
const ONLY_HOSTS: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:24:11 +02:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.krate("rustc-main").default_condition(builder.config.docs)
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure(Rustc {
|
|
|
|
stage: run.builder.top_stage,
|
|
|
|
target: run.target,
|
2017-07-21 01:24:11 +02:00
|
|
|
});
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2019-02-08 14:53:55 +01:00
|
|
|
/// Generates compiler documentation.
|
2017-07-05 03:41:43 +02:00
|
|
|
///
|
2018-03-20 03:06:38 +01:00
|
|
|
/// This will generate all documentation for compiler and dependencies.
|
|
|
|
/// Compiler documentation is distributed separately, so we make sure
|
|
|
|
/// we do not merge it with the other documentation from std, test and
|
|
|
|
/// proc_macros. This is largely just a wrapper around `cargo doc`.
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let stage = self.stage;
|
|
|
|
let target = self.target;
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Documenting stage{} compiler ({})", stage, target));
|
2018-05-19 17:21:17 +02:00
|
|
|
|
|
|
|
// This is the intended out directory for compiler documentation.
|
2018-04-15 01:27:57 +02:00
|
|
|
let out = builder.compiler_doc_out(target);
|
2017-07-05 03:41:43 +02:00
|
|
|
t!(fs::create_dir_all(&out));
|
2018-05-19 17:21:17 +02:00
|
|
|
|
|
|
|
// Get the correct compiler for this stage.
|
2019-05-28 19:00:53 +02:00
|
|
|
let compiler = builder.compiler_for(stage, builder.config.build, target);
|
2017-07-05 14:41:27 +02:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
if !builder.config.compiler_docs {
|
2018-07-28 14:40:32 +02:00
|
|
|
builder.info("\tskipping - compiler/librustdoc docs disabled");
|
2018-03-20 03:06:38 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-05-19 17:21:17 +02:00
|
|
|
// Build rustc.
|
2017-07-05 14:41:27 +02:00
|
|
|
builder.ensure(compile::Rustc { compiler, target });
|
2018-05-19 17:21:17 +02:00
|
|
|
|
2018-03-22 21:49:05 +01:00
|
|
|
// We do not symlink to the same shared folder that already contains std library
|
|
|
|
// documentation from previous steps as we do not want to include that.
|
2018-05-19 22:04:41 +02:00
|
|
|
let out_dir = builder.stage_out(compiler, Mode::Rustc).join(target).join("doc");
|
2018-03-27 16:06:47 +02:00
|
|
|
t!(symlink_dir_force(&builder.config, &out, &out_dir));
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-05-19 17:21:17 +02:00
|
|
|
// Build cargo command.
|
2018-05-19 22:04:41 +02:00
|
|
|
let mut cargo = builder.cargo(compiler, Mode::Rustc, target, "doc");
|
2019-05-16 20:32:28 +02:00
|
|
|
cargo.env("RUSTDOCFLAGS", "--document-private-items --passes strip-hidden");
|
2019-10-22 17:51:35 +02:00
|
|
|
compile::rustc_cargo(builder, &mut cargo, target);
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-03-22 15:57:28 +01:00
|
|
|
// Only include compiler crates, no dependencies of those, such as `libc`.
|
|
|
|
cargo.arg("--no-deps");
|
|
|
|
|
|
|
|
// Find dependencies for top level crates.
|
|
|
|
let mut compiler_crates = HashSet::new();
|
2018-12-02 17:55:00 +01:00
|
|
|
for root_crate in &["rustc_driver", "rustc_codegen_llvm", "rustc_codegen_ssa"] {
|
2018-03-22 15:57:28 +01:00
|
|
|
let interned_root_crate = INTERNER.intern_str(root_crate);
|
2018-04-15 01:27:57 +02:00
|
|
|
find_compiler_crates(builder, &interned_root_crate, &mut compiler_crates);
|
2018-03-22 15:57:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
for krate in &compiler_crates {
|
2018-12-02 17:55:00 +01:00
|
|
|
// Create all crate output directories first to make sure rustdoc uses
|
|
|
|
// relative links.
|
|
|
|
// FIXME: Cargo should probably do this itself.
|
|
|
|
t!(fs::create_dir_all(out_dir.join(krate)));
|
2018-03-22 15:57:28 +01:00
|
|
|
cargo.arg("-p").arg(krate);
|
|
|
|
}
|
2017-03-02 00:34:54 +01:00
|
|
|
|
2019-09-09 19:17:38 +02:00
|
|
|
builder.run(&mut cargo.into());
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2016-03-08 07:36:21 +01:00
|
|
|
}
|
2016-03-08 22:42:32 +01:00
|
|
|
|
2018-03-22 15:57:28 +01:00
|
|
|
fn find_compiler_crates(
|
2019-02-25 11:30:32 +01:00
|
|
|
builder: &Builder<'_>,
|
2018-03-22 15:57:28 +01:00
|
|
|
name: &Interned<String>,
|
|
|
|
crates: &mut HashSet<Interned<String>>
|
|
|
|
) {
|
|
|
|
// Add current crate.
|
|
|
|
crates.insert(*name);
|
|
|
|
|
|
|
|
// Look for dependencies.
|
2018-04-15 01:27:57 +02:00
|
|
|
for dep in builder.crates.get(name).unwrap().deps.iter() {
|
|
|
|
if builder.crates.get(dep).unwrap().is_local(builder) {
|
|
|
|
find_compiler_crates(builder, dep, crates);
|
2018-03-22 15:57:28 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-19 17:21:17 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct Rustdoc {
|
|
|
|
stage: u32,
|
|
|
|
target: Interned<String>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Step for Rustdoc {
|
|
|
|
type Output = ();
|
|
|
|
const DEFAULT: bool = true;
|
|
|
|
const ONLY_HOSTS: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2018-05-19 17:21:17 +02:00
|
|
|
run.krate("rustdoc-tool")
|
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2018-05-19 17:21:17 +02:00
|
|
|
run.builder.ensure(Rustdoc {
|
|
|
|
stage: run.builder.top_stage,
|
|
|
|
target: run.target,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-02-08 14:53:55 +01:00
|
|
|
/// Generates compiler documentation.
|
2018-05-19 17:21:17 +02:00
|
|
|
///
|
|
|
|
/// This will generate all documentation for compiler and dependencies.
|
|
|
|
/// Compiler documentation is distributed separately, so we make sure
|
|
|
|
/// we do not merge it with the other documentation from std, test and
|
|
|
|
/// proc_macros. This is largely just a wrapper around `cargo doc`.
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2018-05-19 17:21:17 +02:00
|
|
|
let stage = self.stage;
|
|
|
|
let target = self.target;
|
|
|
|
builder.info(&format!("Documenting stage{} rustdoc ({})", stage, target));
|
|
|
|
|
|
|
|
// This is the intended out directory for compiler documentation.
|
|
|
|
let out = builder.compiler_doc_out(target);
|
|
|
|
t!(fs::create_dir_all(&out));
|
|
|
|
|
|
|
|
// Get the correct compiler for this stage.
|
2019-05-28 19:00:53 +02:00
|
|
|
let compiler = builder.compiler_for(stage, builder.config.build, target);
|
2018-05-19 17:21:17 +02:00
|
|
|
|
|
|
|
if !builder.config.compiler_docs {
|
2018-07-28 14:40:32 +02:00
|
|
|
builder.info("\tskipping - compiler/librustdoc docs disabled");
|
2018-05-19 17:21:17 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-12-02 17:55:00 +01:00
|
|
|
// Build rustc docs so that we generate relative links.
|
|
|
|
builder.ensure(Rustc { stage, target });
|
2018-05-19 17:21:17 +02:00
|
|
|
|
|
|
|
// Build rustdoc.
|
2019-03-03 17:50:56 +01:00
|
|
|
builder.ensure(tool::Rustdoc { compiler: compiler });
|
2018-05-19 17:21:17 +02:00
|
|
|
|
|
|
|
// Symlink compiler docs to the output directory of rustdoc documentation.
|
2018-06-29 23:35:10 +02:00
|
|
|
let out_dir = builder.stage_out(compiler, Mode::ToolRustc)
|
|
|
|
.join(target)
|
|
|
|
.join("doc");
|
2018-05-19 17:21:17 +02:00
|
|
|
t!(fs::create_dir_all(&out_dir));
|
|
|
|
t!(symlink_dir_force(&builder.config, &out, &out_dir));
|
|
|
|
|
|
|
|
// Build cargo command.
|
2018-05-28 01:56:33 +02:00
|
|
|
let mut cargo = prepare_tool_cargo(
|
2018-06-29 23:35:10 +02:00
|
|
|
builder,
|
|
|
|
compiler,
|
|
|
|
Mode::ToolRustc,
|
|
|
|
target,
|
|
|
|
"doc",
|
|
|
|
"src/tools/rustdoc",
|
2018-07-26 05:36:58 +02:00
|
|
|
SourceType::InTree,
|
2018-10-08 19:39:09 +02:00
|
|
|
&[]
|
2018-06-29 23:35:10 +02:00
|
|
|
);
|
2018-05-28 01:56:33 +02:00
|
|
|
|
2018-12-02 17:55:00 +01:00
|
|
|
// Only include compiler crates, no dependencies of those, such as `libc`.
|
|
|
|
cargo.arg("--no-deps");
|
|
|
|
cargo.arg("-p").arg("rustdoc");
|
|
|
|
|
2018-05-19 17:21:17 +02:00
|
|
|
cargo.env("RUSTDOCFLAGS", "--document-private-items");
|
2019-09-09 19:17:38 +02:00
|
|
|
builder.run(&mut cargo.into());
|
2018-05-19 17:21:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct ErrorIndex {
|
|
|
|
target: Interned<String>,
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2016-03-08 22:42:32 +01:00
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for ErrorIndex {
|
2017-07-05 03:41:43 +02:00
|
|
|
type Output = ();
|
2017-07-05 14:41:27 +02:00
|
|
|
const DEFAULT: bool = true;
|
|
|
|
const ONLY_HOSTS: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:24:11 +02:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.path("src/tools/error_index_generator").default_condition(builder.config.docs)
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure(ErrorIndex {
|
|
|
|
target: run.target,
|
2017-07-05 14:41:27 +02:00
|
|
|
});
|
|
|
|
}
|
2017-07-05 03:41:43 +02:00
|
|
|
|
|
|
|
/// Generates the HTML rendered error-index by running the
|
|
|
|
/// `error_index_generator` tool.
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let target = self.target;
|
2017-07-05 14:41:27 +02:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Documenting error index ({})", target));
|
|
|
|
let out = builder.doc_out(target);
|
2017-07-05 03:41:43 +02:00
|
|
|
t!(fs::create_dir_all(&out));
|
2019-03-03 17:29:59 +01:00
|
|
|
let compiler = builder.compiler(2, builder.config.build);
|
|
|
|
let mut index = tool::ErrorIndex::command(
|
|
|
|
builder,
|
|
|
|
compiler,
|
|
|
|
);
|
2017-07-05 03:41:43 +02:00
|
|
|
index.arg("html");
|
|
|
|
index.arg(out.join("error-index.html"));
|
2019-03-26 23:57:16 +01:00
|
|
|
index.arg(crate::channel::CFG_RELEASE_NUM);
|
2017-07-05 03:41:43 +02:00
|
|
|
|
|
|
|
// FIXME: shouldn't have to pass this env var
|
2019-08-20 00:26:08 +02:00
|
|
|
index.env("CFG_BUILD", &builder.config.build);
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.run(&mut index);
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2016-03-08 22:42:32 +01:00
|
|
|
}
|
2017-03-02 00:34:54 +01:00
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
|
|
pub struct UnstableBookGen {
|
|
|
|
target: Interned<String>,
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2017-06-12 21:35:47 +02:00
|
|
|
|
2017-07-14 02:48:44 +02:00
|
|
|
impl Step for UnstableBookGen {
|
2017-07-05 03:41:43 +02:00
|
|
|
type Output = ();
|
2017-07-05 14:41:27 +02:00
|
|
|
const DEFAULT: bool = true;
|
|
|
|
const ONLY_HOSTS: bool = true;
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
|
2017-07-21 01:24:11 +02:00
|
|
|
let builder = run.builder;
|
2018-04-15 01:27:57 +02:00
|
|
|
run.path("src/tools/unstable-book-gen").default_condition(builder.config.docs)
|
2017-07-05 14:41:27 +02:00
|
|
|
}
|
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn make_run(run: RunConfig<'_>) {
|
2017-07-21 01:51:07 +02:00
|
|
|
run.builder.ensure(UnstableBookGen {
|
|
|
|
target: run.target,
|
2017-07-05 14:41:27 +02:00
|
|
|
});
|
|
|
|
}
|
2017-07-05 03:41:43 +02:00
|
|
|
|
2019-02-25 11:30:32 +01:00
|
|
|
fn run(self, builder: &Builder<'_>) {
|
2017-07-05 03:41:43 +02:00
|
|
|
let target = self.target;
|
2017-07-05 14:41:27 +02:00
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.info(&format!("Generating unstable book md files ({})", target));
|
|
|
|
let out = builder.md_doc_out(target).join("unstable-book");
|
|
|
|
builder.create_dir(&out);
|
|
|
|
builder.remove_dir(&out);
|
2017-07-05 18:46:41 +02:00
|
|
|
let mut cmd = builder.tool_cmd(Tool::UnstableBookGen);
|
2018-04-15 01:27:57 +02:00
|
|
|
cmd.arg(builder.src.join("src"));
|
2017-07-05 03:41:43 +02:00
|
|
|
cmd.arg(out);
|
|
|
|
|
2018-04-15 01:27:57 +02:00
|
|
|
builder.run(&mut cmd);
|
2017-07-05 03:41:43 +02:00
|
|
|
}
|
2017-06-12 21:35:47 +02:00
|
|
|
}
|
|
|
|
|
2018-03-27 16:06:47 +02:00
|
|
|
fn symlink_dir_force(config: &Config, src: &Path, dst: &Path) -> io::Result<()> {
|
|
|
|
if config.dry_run {
|
|
|
|
return Ok(());
|
|
|
|
}
|
2017-03-02 00:34:54 +01:00
|
|
|
if let Ok(m) = fs::symlink_metadata(dst) {
|
|
|
|
if m.file_type().is_dir() {
|
2018-12-01 22:48:55 +01:00
|
|
|
fs::remove_dir_all(dst)?;
|
2017-03-02 00:34:54 +01:00
|
|
|
} else {
|
|
|
|
// handle directory junctions on windows by falling back to
|
|
|
|
// `remove_dir`.
|
2018-12-01 22:48:55 +01:00
|
|
|
fs::remove_file(dst).or_else(|_| {
|
2017-03-02 00:34:54 +01:00
|
|
|
fs::remove_dir(dst)
|
2018-12-01 22:48:55 +01:00
|
|
|
})?;
|
2017-03-02 00:34:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-27 16:06:47 +02:00
|
|
|
symlink_dir(config, src, dst)
|
2017-03-02 00:34:54 +01:00
|
|
|
}
|