Merge pull request #11 from rust-lang/master

Merge pull request rust-lang#2350 from rust-lang/steveklabnik-patch-2

Author: fengjixuchui

.github/workflows/main.yml

@@ -0,0 +1,64 @@
+name: CI
+on: [push, pull_request]
+
+jobs:
+  test:
+    name: Run tests
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+    - name: Update rustup
+      run: rustup self update
+    - name: Install Rust
+      run: |
+        rustup set profile minimal
+        rustup toolchain install 1.41.0 -c rust-docs
+        rustup default 1.41.0
+    - name: Install mdbook
+      run: |
+        mkdir bin
+        curl -sSL https://github.com/rust-lang/mdBook/releases/download/v0.3.5/mdbook-v0.3.5-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=bin
+        echo "##[add-path]$(pwd)/bin"
+    - name: Report versions
+      run: |
+        rustup --version
+        rustc -Vv
+        mdbook --version
+    - name: Run tests
+      run: mdbook test
+  lint:
+    name: Run lints
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+    - name: Update rustup
+      run: rustup self update
+    - name: Install Rust
+      run: |
+        rustup set profile minimal
+        rustup toolchain install nightly -c rust-docs
+        rustup default nightly
+    - name: Install mdbook
+      run: |
+        mkdir bin
+        curl -sSL https://github.com/rust-lang/mdBook/releases/download/v0.3.5/mdbook-v0.3.5-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=bin
+        echo "##[add-path]$(pwd)/bin"
+    - name: Report versions
+      run: |
+        rustup --version
+        rustc -Vv
+        mdbook --version
+    - name: Spellcheck
+      run: bash ci/spellcheck.sh list
+    - name: Lint for local file paths
+      run: | 
+        mdbook build
+        cargo run --bin lfp src
+    - name: Validate references
+      run: bash ci/validate.sh
+    - name: Check for broken links
+      run: |
+        curl -sSLo linkcheck.sh \
+          https://raw.githubusercontent.com/rust-lang/rust/master/src/tools/linkchecker/linkcheck.sh
+        # Cannot use --all here because of the generated redirect pages aren't available.
+        sh linkcheck.sh book

.travis.yml

@@ -5,7 +5,7 @@ occasional maintenance tasks.
 
 ## Update the `rustc` version
 
-- Change the version number in `.travis.yml`
+- Change the version number in `.github/workflows/main.yml`
 - Change the version number in `rust-toolchain`, which should change the version you're using
   locally with `rustup`
 - Change the version number in `src/title-page.md`

ADMIN_TASKS.md

@@ -1,6 +1,6 @@
 # The Rust Programming Language
 
-[![Build Status](https://travis-ci.com/rust-lang/book.svg?branch=master)](https://travis-ci.com/rust-lang/book)
+![Build Status](https://github.com/rust-lang/book/workflows/CI/badge.svg)
 
 This repository contains the source of "The Rust Programming Language" book.
 

README.md

@@ -0,0 +1,4 @@
+for file in src/*.md ; do
+    echo Checking references in $file
+    cargo run --quiet --bin link2print < $file > /dev/null
+done

ci/build.sh

@@ -39,24 +39,6 @@ for your password. If the install is successful, the following line will appear:
 Rust is installed now. Great!
 ```
 
-If you prefer, feel free to download the script and inspect it before running
-it.
-
-The installation script automatically adds Rust to your system PATH after your
-next login. If you want to start using Rust right away instead of restarting
-your terminal, run the following command in your shell to add Rust to your
-system PATH manually:
-
-```text
-$ source $HOME/.cargo/env
-```
-
-Alternatively, you can add the following line to your *~/.bash_profile*:
-
-```text
-$ export PATH="$HOME/.cargo/bin:$PATH"
-```
-
 Additionally, you’ll need a linker of some kind. It’s likely one is already
 installed, but when you try to compile a Rust program and get errors indicating
 that a linker could not execute, that means a linker isn’t installed on your

ci/validate.sh

@@ -42,7 +42,7 @@ strings.
 > All data stored on the stack must have a known, fixed size. Data with an
 > unknown size at compile time or a size that might change must be stored on
 > the heap instead. The heap is less organized: when you put data on the heap,
-> you request a certain amount of space. The operating system finds an empty
+> you request a certain amount of space. The memory allocator finds an empty
 > spot in the heap that is big enough, marks it as being in use, and returns a
 > *pointer*, which is the address of that location. This process is called
 > *allocating on the heap* and is sometimes abbreviated as just *allocating*.
@@ -56,9 +56,9 @@ strings.
 > you’ve been seated to find you.
 >
 > Pushing to the stack is faster than allocating on the heap because the
-> operating system never has to search for a place to store new data; that
+> allocator never has to search for a place to store new data; that
 > location is always at the top of the stack. Comparatively, allocating space
-> on the heap requires more work, because the operating system must first find
+> on the heap requires more work, because the allocator must first find
 > a big enough space to hold the data and then perform bookkeeping to prepare
 > for the next allocation.
 >
@@ -189,8 +189,8 @@ With the `String` type, in order to support a mutable, growable piece of text,
 we need to allocate an amount of memory on the heap, unknown at compile time,
 to hold the contents. This means:
 
-* The memory must be requested from the operating system at runtime.
-* We need a way of returning this memory to the operating system when we’re
+* The memory must be requested from the memory allocator at runtime.
+* We need a way of returning this memory to the allocator when we’re
   done with our `String`.
 
 That first part is done by us: when we call `String::from`, its implementation
@@ -215,7 +215,7 @@ from Listing 4-1 using a `String` instead of a string literal:
 ```
 
 There is a natural point at which we can return the memory our `String` needs
-to the operating system: when `s` goes out of scope. When a variable goes out
+to the allocator: when `s` goes out of scope. When a variable goes out
 of scope, Rust calls a special function for us. This function is called `drop`,
 and it’s where the author of `String` can put the code to return the memory.
 Rust calls `drop` automatically at the closing curly bracket.
@@ -271,7 +271,7 @@ holding the value `"hello"` bound to `s1`</span>
 
 The length is how much memory, in bytes, the contents of the `String` is
 currently using. The capacity is the total amount of memory, in bytes, that the
-`String` has received from the operating system. The difference between length
+`String` has received from the allocator. The difference between length
 and capacity matters, but not in this context, so for now, it’s fine to ignore
 the capacity.
 

src/ch01-01-installation.md

@@ -179,7 +179,7 @@ Adding `rand` as a dependency in *Cargo.toml* tells Cargo to download the
 make `rand` available to our project.
 
 Then, to bring `rand` definitions into the scope of our package, we added a
-`use` line starting with the name of the package, `rand`, and listed the items
+`use` line starting with the name of the crate, `rand`, and listed the items
 we wanted to bring into scope. Recall that in the [“Generating a Random
 Number”][rand]<!-- ignore --> section in Chapter 2, we brought the `Rng` trait
 into scope and called the `rand::thread_rng` function:
@@ -191,7 +191,7 @@ into scope and called the `rand::thread_rng` function:
 Members of the Rust community have made many packages available at
 [crates.io](https://crates.io/), and pulling any of them into your package
 involves these same steps: listing them in your package’s *Cargo.toml* file and
-using `use` to bring items into scope.
+using `use` to bring items from their crates into scope.
 
 Note that the standard library (`std`) is also a crate that’s external to our
 package. Because the standard library is shipped with the Rust language, we
@@ -208,7 +208,7 @@ crate.
 
 ### Using Nested Paths to Clean Up Large `use` Lists
 
-If we’re using multiple items defined in the same package or same module,
+If we’re using multiple items defined in the same crate or same module,
 listing each item on its own line can take up a lot of vertical space in our
 files. For example, these two `use` statements we had in the Guessing Game in
 Listing 2-4 bring items from `std` into scope:
@@ -233,7 +233,7 @@ differ, as shown in Listing 7-18.
 <span class="caption">Listing 7-18: Specifying a nested path to bring multiple
 items with the same prefix into scope</span>
 
-In bigger programs, bringing many items into scope from the same package or
+In bigger programs, bringing many items into scope from the same crate or
 module using nested paths can reduce the number of separate `use` statements
 needed by a lot!
 

src/ch04-01-what-is-ownership.md

@@ -6,7 +6,7 @@ provide an implementation for the `Drop` trait on any type, and the code you
 specify can be used to release resources like files or network connections.
 We’re introducing `Drop` in the context of smart pointers because the
 functionality of the `Drop` trait is almost always used when implementing a
-smart pointer. For example, `Box<T>` customizes `Drop` to deallocate the space
+smart pointer. For example, when a `Box<T>` is dropped it will deallocate the space
 on the heap that the box points to.
 
 In some languages, the programmer must call code to free memory or resources

src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md

@@ -148,13 +148,14 @@ for the next time we ask for data. It therefore needs to be `mut` because its
 internal state might change; usually, we think of “reading” as not needing
 mutation, but in this case we need the `mut` keyword.
 
-Next, we need to actually read from the stream. We do this in two steps: first,
-we declare a `buffer` on the stack to hold the data that is read in. We’ve made
-the buffer 512 bytes in size, which is big enough to hold the data of a basic
-request and sufficient for our purposes in this chapter. If we wanted to handle
-requests of an arbitrary size, buffer management would need to be more
-complicated; we’ll keep it simple for now. We pass the buffer to `stream.read`,
-which will read bytes from the `TcpStream` and put them in the buffer.
+Next, we need to actually read from the stream. We do this in two steps:
+first, we declare a `buffer` on the stack to hold the data that is read in.
+We’ve made the buffer 1024 bytes in size, which is big enough to hold the
+data of a basic request and sufficient for our purposes in this chapter. If
+we wanted to handle requests of an arbitrary size, buffer management would
+need to be more complicated; we’ll keep it simple for now. We pass the buffer
+to `stream.read`, which will read bytes from the `TcpStream` and put them in
+the buffer.
 
 Second, we convert the bytes in the buffer to a string and print that string.
 The `String::from_utf8_lossy` function takes a `&[u8]` and produces a `String`