Using Rust Toolset

Red Hat Developer Tools 2019.3

Installing and using Rust Toolset 1.35.0

Peter Macko

pmacko@redhat.com

Kevin Owen

Vladimir Slavik

Red Hat Developer Group Documentation Team devtools-docs@redhat.com

Legal Notice

Abstract

Rust Toolset is a Red Hat offering for developers on the Red Hat Enterprise Linux platform. The Rust Toolset User Guide provides an overview of this product, explains how to invoke and use the Rust Toolset versions of the tools, and links to resources with more in-depth information.

Chapter 1. Rust Toolset
Copy link

1.1. About Rust Toolset
Copy link

Rust Toolset is a Red Hat offering for developers on the Red Hat Enterprise Linux platform. It provides the Rust programming language compiler rustc, the cargo build tool and dependency manager, the cargo-vendor plug-in, the rustfmt tool, and required libraries.

Rust Toolset is distributed as a part of Red Hat Developer Tools for Red Hat Enterprise Linux 7 and is available as a module in Red Hat Enterprise Linux 8.

The following components are available as a part of Rust Toolset:

Expand

Table 1.1. Rust Toolset Components
Name	Version	Description
rust	1.35.0	A Rust compiler front-end for LLVM.
cargo	1.35.0	A build system and dependency manager for Rust.
cargo-vendor	0.1.23	A cargo subcommand to vendor crates.io dependencies.
rustfmt	1.35.0	A tool for automatic formatting of Rust code.

1.2. Compatibility
Copy link

Rust Toolset is available for Red Hat Enterprise Linux 7 and Red Hat Enterprise Linux 8 on the following architectures:

The 64-bit Intel and AMD architectures
The 64-bit ARM architecture
The IBM Power Systems architecture
The little-endian variant of IBM Power Systems architecture
The IBM Z Systems architecture

1.3. Getting Access to Rust Toolset on Red Hat Enterprise Linux 7
Copy link

Rust Toolset is an offering that is distributed as a part of the Red Hat Developer Tools content set, which is available to customers with deployments of Red Hat Enterprise Linux 7. In order to install Rust Toolset, enable the Red Hat Developer Tools and Red Hat Software Collections repositories by using the Red Hat Subscription Management and add the Red Hat Developer Tools GPG key to your system.

Enable the rhel-7-variant-devtools-rpms repository:
```
subscription-manager repos --enable rhel-7-variant-devtools-rpms
```
```
# subscription-manager repos --enable rhel-7-variant-devtools-rpms
```
Copy to Clipboard Toggle word wrap
Replace variant with the Red Hat Enterprise Linux system variant (server or workstation).
Note
Consider using Red Hat Enterprise Linux Server to access the widest range of the development tools.
Enable the rhel-variant-rhscl-7-rpms repository:
```
subscription-manager repos --enable rhel-variant-rhscl-7-rpms
```
```
# subscription-manager repos --enable rhel-variant-rhscl-7-rpms
```
Copy to Clipboard Toggle word wrap
Replace variant with the Red Hat Enterprise Linux system variant (server or workstation).

Add the Red Hat Developer Tools key to your system:

cd /etc/pki/rpm-gpg
wget -O RPM-GPG-KEY-redhat-devel https://www.redhat.com/security/data/a5787476.txt
rpm --import RPM-GPG-KEY-redhat-devel

# cd /etc/pki/rpm-gpg
# wget -O RPM-GPG-KEY-redhat-devel https://www.redhat.com/security/data/a5787476.txt
# rpm --import RPM-GPG-KEY-redhat-devel

Copy to Clipboard

Toggle word wrap

Once the subscription is attached to the system and repositories enabled, you can install Red Hat Rust Toolset as described in Section 1.4, “Installing Rust Toolset”.

Additional Resources

For more information on how to register your system using Red Hat Subscription Management and associate it with subscriptions, see the Red Hat Subscription Management collection of guides.
For detailed instructions on subscription to Red Hat Software Collections, see the Red Hat Developer Toolset User Guide, Section 1.4. Getting Access to Red Hat Developer Toolset.

1.4. Installing Rust Toolset
Copy link

Rust Toolset is distributed as a collection of RPM packages that can be installed, updated, uninstalled, and inspected by using the standard package management tools that are included in Red Hat Enterprise Linux. Note that a valid subscription that provides access to the Red Hat Developer Tools content set is required in order to install Rust Toolset on a Red Hat Enterprise Linux 7 system. For detailed instructions on how to associate your Red Hat Enterprise Linux 7 system with an appropriate subscription and get access to Rust Toolset, see Section 1.3, “Getting Access to Rust Toolset on Red Hat Enterprise Linux 7”.

Important

Before installing Rust Toolset, install all available Red Hat Enterprise Linux updates.

Install all of the components included in Rust Toolset for your operating system:
- On Red Hat Enterprise Linux 7, install the rust-toolset-1.35 package:
  # yum install rust-toolset-1.35
  Copy to Clipboard Toggle word wrap
- On Red Hat Enterprise Linux 8, install the rust-toolset module:
  # yum module install rust-toolset
  Copy to Clipboard Toggle word wrap
  This installs all development and debugging tools, and other dependent packages to the system. Notably, Rust Toolset has a dependency on Clang and LLVM Toolset.

1.5. Additional Resources
Copy link

A detailed description of the Rust programming language and all its features is beyond the scope of this book. For more information, see the resources listed below.

Installable Documentation

Install The Rust Programming Language book and API documentation in HTML format:
- On Red Hat Enterprise Linux 7, install the rust-toolset-1.35-rust-doc package:
  # yum install rust-toolset-1.35-rust-doc
  Copy to Clipboard Toggle word wrap
  The book is available in /opt/rh/rust-toolset-1.35/usr/share/doc/rust/html/index.html
  The API documentation for all crates is available in HTML format in /opt/rh/rust-toolset-1.35/usr/share/doc/rust/html/std/index.html.
- On Red Hat Enterprise Linux 8, install the rust-doc package:
  # yum install rust-doc
  Copy to Clipboard Toggle word wrap
  The book is available in /usr/share/doc/rust/html/index.html
  The API documentation for all crates is available in HTML format in /usr/share/doc/rust/html/std/index.html.

Online Documentation

Rust documentation — The upstream Rust documentation.

Chapter 2. cargo
Copy link

cargo is a tool for development using the Rust programming language. cargo fulfills the following roles:

Build tool and frontend for the Rust compiler rustc.
Note
Consider using cargo over rustc.
Package and dependency manager.
cargo allows Rust projects to declare dependencies with specific version requirement. cargo will resolve the full dependency graph, download packages as needed, and build and test the entire project.

Rust Toolset is distributed with cargo 1.35.0.

2.1. Installing cargo
Copy link

Install Rust Toolset, see Section 1.4, “Installing Rust Toolset”.
Note
cargo is installed as a part of Rust Toolset.
On Red Hat Enterprise Linux 7, cargo is provided by the rust-toolset-1.35-cargo package.
On Red Hat Enterprise Linux 8, cargo is provided by the rust-toolset module.

2.2. Creating a New Project
Copy link

To create a Rust program on the command line, run the cargo tool as follows:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo new --bin project_name'

$ scl enable rust-toolset-1.35 'cargo new --bin project_name'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo new --bin project_name
```
```
$ cargo new --bin project_name
```
Copy to Clipboard Toggle word wrap

This creates a directory project_name containing a text file named Cargo.toml and a subdirectory src containing a text file named main.rs.

To configure the project and add dependencies, edit the file Cargo.toml. See Section 2.7, “Configuring Project Dependencies”.

To edit the project code, edit the file main.rs and add new source files in the src subdirectory as needed.

To create a project for a cargo package instead of a program, run the cargo tool on the command line as follows:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo new --lib project_name'

$ scl enable rust-toolset-1.35 'cargo new --lib project_name'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo new --lib project_name
```
```
$ cargo new --lib project_name
```
Copy to Clipboard Toggle word wrap

Note that you can execute any command using the scl utility on Red Hat Enterprise Linux 7, causing it to be run with the Rust Toolset binaries available. This allows you to run a shell session with Rust Toolset cargo command directly available:

scl enable rust-toolset-1.35 'bash'

$ scl enable rust-toolset-1.35 'bash'

Copy to Clipboard

Toggle word wrap

Example 2.1. Creating a Project using cargo

Create a new Rust project called helloworld:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo new --bin helloworld'
     Created binary (application) helloworld project

$ scl enable rust-toolset-1.35 'cargo new --bin helloworld'
     Created binary (application) helloworld project

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo new --bin helloworld
     Created binary (application) helloworld project

$ cargo new --bin helloworld
     Created binary (application) helloworld project

Copy to Clipboard

Toggle word wrap

Examine the result:

cd helloworld
tree
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files
cat src/main.rs
fn main() {
    println!("Hello, world!");
}

$ cd helloworld
$ tree
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files
$ cat src/main.rs
fn main() {
    println!("Hello, world!");
}

Copy to Clipboard

Toggle word wrap

A directory helloworld is created for the project, with a file Cargo.toml for tracking project metadata, and a subdirectory src containing the main source code file main.rs.

The source code file main.rs has been initialized by cargo to a sample hello world program.

Note

The tree tool is available from the default Red Hat Enterprise Linux repositories. To install it:

yum install tree

# yum install tree

Copy to Clipboard

Toggle word wrap

2.3. Building a Project
Copy link

To build a Rust project on the command line, change to the project directory and run the cargo tool as follows:

For Red Hat Enterprise Linux 7:
```
scl enable rust-toolset-1.35 'cargo build'
```
```
$ scl enable rust-toolset-1.35 'cargo build'
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
cargo build
```
```
$ cargo build
```
Copy to Clipboard Toggle word wrap

This resolves all dependencies of the project, downloads the missing dependencies, and compiles the project using the rustc compiler.

By default, the project is built and compiled in debug mode. To build the project in release mode, run the cargo tool with the --release option as follows:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo build --release'

$ scl enable rust-toolset-1.35 'cargo build --release'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo build --release
```
```
$ cargo build --release
```
Copy to Clipboard Toggle word wrap

Example 2.2. Building a Project using cargo

This example assumes that you have successfully created the Rust project helloworld according to Example 2.1, “Creating a Project using cargo”.

Change to the directory helloworld and build the project:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo build'
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.51 secs

$ scl enable rust-toolset-1.35 'cargo build'
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.51 secs

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo build
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.51 secs

$ cargo build
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.51 secs

Copy to Clipboard

Toggle word wrap

Examine the result:

tree
.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── target
    └── debug
        ├── build
        ├── deps
        │   └── helloworld-b7c6fab39c2d17a7
        ├── examples
        ├── helloworld
        ├── helloworld.d
        ├── incremental
        └── native

8 directories, 6 files

$ tree
.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── target
    └── debug
        ├── build
        ├── deps
        │   └── helloworld-b7c6fab39c2d17a7
        ├── examples
        ├── helloworld
        ├── helloworld.d
        ├── incremental
        └── native

8 directories, 6 files

Copy to Clipboard

Toggle word wrap

A subdirectory structure has been created, starting with the directory target. Since the project was built in debug mode, the actual build output is contained in a further subdirectory debug. The actual resulting executable file is target/debug/helloworld.

Note

The tree tool is available from the default Red Hat Enterprise Linux repositories. To install it:

yum install tree

# yum install tree

Copy to Clipboard

Toggle word wrap

2.4. Checking a Program
Copy link

To verify that a Rust program managed by cargo can be built, on the command line change to the project directory and run the cargo tool as follows:

For Red Hat Enterprise Linux 7:
```
scl enable rust-toolset-1.35 'cargo check'
```
```
$ scl enable rust-toolset-1.35 'cargo check'
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
cargo check
```
```
$ cargo check
```
Copy to Clipboard Toggle word wrap

Note

Consider using cargo check over cargo build for verification of a Rust program validity when you do not need the executable code. The cargo check command is faster than a full project build using the cargo build command, because it does not generate the executable code.

By default, the project is checked in debug mode. To check the project in release mode, run the cargo tool with the --release option as follows:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo check --release'

$ scl enable rust-toolset-1.35 'cargo check --release'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo check --release
```
```
$ cargo check --release
```
Copy to Clipboard Toggle word wrap

Example 2.3. Checking a Program with cargo

This example assumes that you have successfully built the Rust project helloworld according to Example 2.2, “Building a Project using cargo”.

Change to the directory helloworld and check the project:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo check'
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.5 secs

$ scl enable rust-toolset-1.35 'cargo check'
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.5 secs

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo check
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.5 secs

$ cargo check
   Compiling helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.5 secs

Copy to Clipboard

Toggle word wrap

The project is checked, with output similar to that of the cargo build command. However, the executable file is not generated. You can verify this by comparing the current time with the time stamp of the executable file:

date
Fri Oct 13 08:53:21 CEST 2017
ls -l target/debug/helloworld
-rwxrwxr-x. 2 vslavik vslavik 252624 Oct 13 08:48 target/debug/helloworld

$ date
Fri Oct 13 08:53:21 CEST 2017
$ ls -l target/debug/helloworld
-rwxrwxr-x. 2 vslavik vslavik 252624 Oct 13 08:48 target/debug/helloworld

Copy to Clipboard

Toggle word wrap

2.5. Running a Program
Copy link

To run a Rust program managed as a project by cargo on the command line, change to the project directory and run the cargo tool as follows:

For Red Hat Enterprise Linux 7:
```
scl enable rust-toolset-1.35 'cargo run'
```
```
$ scl enable rust-toolset-1.35 'cargo run'
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
cargo run
```
```
$ cargo run
```
Copy to Clipboard Toggle word wrap

If the program has not been built yet, cargo will run a build before running the program.

Note

Consider using cargo to run a Rust program during development. It will correctly resolve the output path independently of the build mode.

By default, the project is built in debug mode. To build the project in release mode before running, run the cargo tool with the --release option as follows:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo run --release'

$ scl enable rust-toolset-1.35 'cargo run --release'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo run --release
```
```
$ cargo run --release
```
Copy to Clipboard Toggle word wrap

Example 2.4. Running a Program with cargo

This example assumes that you have successfully built the Rust project helloworld according to Example 2.2, “Building a Project using cargo”.

Change to the directory helloworld and run the project:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo run'
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running target/debug/helloworld
Hello, world!

$ scl enable rust-toolset-1.35 'cargo run'
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running target/debug/helloworld
Hello, world!

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running target/debug/helloworld
Hello, world!

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running target/debug/helloworld
Hello, world!

Copy to Clipboard

Toggle word wrap

cargo first rebuilds the project, and then runs the resulting executable file.

In this example, there were no changes to the source code since last build. As a result, cargo did not have to rebuild the executable file, but merely accepted it as current.

2.6. Running Project Tests
Copy link

To run tests for a cargo project on the command line, change to the project directory and run the cargo tool as follows:

For Red Hat Enterprise Linux 7:
```
scl enable rust-toolset-1.35 'cargo test'
```
```
$ scl enable rust-toolset-1.35 'cargo test'
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
cargo test
```
```
$ cargo test
```
Copy to Clipboard Toggle word wrap

By default, the project is tested in debug mode. To test the project in release mode, run the cargo tool with the --release option as follows:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo test --release'

$ scl enable rust-toolset-1.35 'cargo test --release'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo test --release
```
```
$ cargo test --release
```
Copy to Clipboard Toggle word wrap

Example 2.5. Testing a Project with cargo

This example assumes that you have successfully built the Rust project helloworld according to Example 2.2, “Building a Project using cargo”.

Change to the directory helloworld, and edit the file src/main.rs so that it contains the following source code:

fn main() {
    println!("Hello, world!");
}

#[test]
fn my_test() {
    assert_eq!(21+21, 42);
}

fn main() {
    println!("Hello, world!");
}

#[test]
fn my_test() {
    assert_eq!(21+21, 42);
}

Copy to Clipboard

Toggle word wrap

The function my_test marked as a test has been added.

Save the file, and run the test:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo test'
   Compiling helloworld v0.1.0 (file:///home/vslavik/Documentation/rusttest/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.26 secs
     Running target/debug/deps/helloworld-9dd6b83647b49aec

running 1 test
test my_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

$ scl enable rust-toolset-1.35 'cargo test'
   Compiling helloworld v0.1.0 (file:///home/vslavik/Documentation/rusttest/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.26 secs
     Running target/debug/deps/helloworld-9dd6b83647b49aec

running 1 test
test my_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo test
   Compiling helloworld v0.1.0 (file:///home/vslavik/Documentation/rusttest/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.26 secs
     Running target/debug/deps/helloworld-9dd6b83647b49aec

running 1 test
test my_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

$ cargo test
   Compiling helloworld v0.1.0 (file:///home/vslavik/Documentation/rusttest/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.26 secs
     Running target/debug/deps/helloworld-9dd6b83647b49aec

running 1 test
test my_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

Copy to Clipboard

Toggle word wrap

cargo first rebuilds the project, and then runs the tests found in the project. The test my_test has been succesfully passed.

2.7. Configuring Project Dependencies
Copy link

To specify dependencies for a cargo project, edit the file Cargo.toml in the project directory. The section [dependencies] contains a list of the project’s dependencies. Each dependency is listed on a new line in the following format:

crate_name = version

crate_name = version

Copy to Clipboard

Toggle word wrap

Rust code packages are called crates.

Example 2.6. Adding Dependency to a Project and Building it with cargo

This example assumes that you have successfully built the Rust project helloworld according to Example 2.2, “Building a Project using cargo”.

Change to the directory helloworld and edit the file src/main.rs so that it contains the following source code:

extern crate time;

fn main() {
    println!("Hello, world!");
    println!("Time is: {}", time::now().rfc822());
}

extern crate time;

fn main() {
    println!("Hello, world!");
    println!("Time is: {}", time::now().rfc822());
}

Copy to Clipboard

Toggle word wrap

The code now requires an external crate time. Add this dependency to project configuration by editing the file Cargo.toml so that it contains the following code:

[package]
name = "helloworld"
version = "0.1.0"
authors = ["Your Name <yourname@example.com>"]

[dependencies]
time = "0.1"

[package]
name = "helloworld"
version = "0.1.0"
authors = ["Your Name <yourname@example.com>"]

[dependencies]
time = "0.1"

Copy to Clipboard

Toggle word wrap

Run the cargo run command to build the project and run the resulting executable file:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo run'
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading time v0.1.38
 Downloading libc v0.2.32
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/helloworld`
Hello, world!
Time is: Fri, 13 Oct 2017 11:08:57

$ scl enable rust-toolset-1.35 'cargo run'
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading time v0.1.38
 Downloading libc v0.2.32
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/helloworld`
Hello, world!
Time is: Fri, 13 Oct 2017 11:08:57

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo run
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading time v0.1.38
 Downloading libc v0.2.32
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/helloworld`
Hello, world!
Time is: Fri, 13 Oct 2017 11:08:57

$ cargo run
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading time v0.1.38
 Downloading libc v0.2.32
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/helloworld`
Hello, world!
Time is: Fri, 13 Oct 2017 11:08:57

Copy to Clipboard

Toggle word wrap

cargo downloads the time crate and its dependencies (crate libc), stores them locally, builds all of the project source code including the dependency crates, and finally runs the resulting executable.

Additional Resources

Specifying Dependencies — official cargo documentation.

2.8. Building Project Documentation
Copy link

Note

Consider using cargo doc over rustdoc. The command cargo doc utilizes the rustdoc utility.

Note

cargo doc extracts documentation comments only for public functions, variables and members.

Rust code can contain comments marked for extraction into documentation. The comments support the Markdown language.

To build project documentation using the cargo tool, change to the project directory and run cargo tool:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo doc --no-deps'

$ scl enable rust-toolset-1.35 'cargo doc --no-deps'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo doc --no-deps
```
```
$ cargo doc --no-deps
```
Copy to Clipboard Toggle word wrap

This extracts documentation stored from the special comments in the source code of your project and writes the documentation in HTML format.

Omit the --no-deps option to include dependencies in the generated documentation, including third party libraries.
Add the --open option to open the generated documentation in your browser.

Example 2.7. Building Project Documentation

This example assumes that you have successfully built the Rust project helloworld with dependencies, according to Example 2.6, “Adding Dependency to a Project and Building it with cargo”.

Change to the directory helloworld and edit the file src/main.rs so that it contains the following source code:

//! This is a hello-world program.
extern crate time;

/// Prints a greeting to `stdout`.
pub fn print_output() {
    println!("Hello, world!");
    println!("Time is: {}", time::now().rfc822());
}

/// The program entry point.
fn main() {
    print_output();
}

//! This is a hello-world program.
extern crate time;

/// Prints a greeting to `stdout`.
pub fn print_output() {
    println!("Hello, world!");
    println!("Time is: {}", time::now().rfc822());
}

/// The program entry point.
fn main() {
    print_output();
}

Copy to Clipboard

Toggle word wrap

The code now contains a public function print_output(). The whole helloworld program, the print_output() function, and the main() function have documentation comments.

Run the cargo doc command to build the project documentation:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo doc --no-deps'
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs

$ scl enable rust-toolset-1.35 'cargo doc --no-deps'
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo doc --no-deps
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs

$ cargo doc --no-deps
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs

Copy to Clipboard

Toggle word wrap

Install tree tool (Available in the default Red Hat Enterprise Linux repositories.), if not already installed:

yum install tree

# yum install tree

Copy to Clipboard

Toggle word wrap

Examine the result:

tree
.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── target
...
    └── doc
...
        ├── helloworld
        │   ├── fn.print_output.html
        │   ├── index.html
        │   ├── print_output.v.html
        │   └── sidebar-items.js
...
        └── src
            └── helloworld
                └── main.rs.html

12 directories, 32 files

$ tree
.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── target
...
    └── doc
...
        ├── helloworld
        │   ├── fn.print_output.html
        │   ├── index.html
        │   ├── print_output.v.html
        │   └── sidebar-items.js
...
        └── src
            └── helloworld
                └── main.rs.html

12 directories, 32 files

Copy to Clipboard

Toggle word wrap

cargo builds the project documentation. To view the documentation, open the file target/doc/helloworld/index.html in your browser. The generated documentation does not contain any mention of the main() function, because it is not public.

Run the cargo doc command without the --no-deps option to build the project documentation, including the dependency libraries time and libc:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo doc'
 Documenting libc v0.2.32
 Documenting time v0.1.38
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 3.41 secs

$ scl enable rust-toolset-1.35 'cargo doc'
 Documenting libc v0.2.32
 Documenting time v0.1.38
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 3.41 secs

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:

cargo doc
 Documenting libc v0.2.32
 Documenting time v0.1.38
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 3.41 secs

$ cargo doc
 Documenting libc v0.2.32
 Documenting time v0.1.38
 Documenting helloworld v0.1.0 (file:///home/vslavik/helloworld)
    Finished dev [unoptimized + debuginfo] target(s) in 3.41 secs

Copy to Clipboard

Toggle word wrap

Examine the resulting folder structure with tree command:

tree
...
92 directories, 11804 files
ls -d target/doc/*/
target/doc/helloworld/  target/doc/implementors/  target/doc/libc/  target/doc/src/  target/doc/time/

$ tree
...
92 directories, 11804 files
$ ls -d target/doc/*/
target/doc/helloworld/  target/doc/implementors/  target/doc/libc/  target/doc/src/  target/doc/time/

Copy to Clipboard

Toggle word wrap

The resulting documentation now covers also the dependency libraries time and libc, with each present as another subdirectory in the target/doc/ directory.

Additional Resources

A detailed description of the cargo doc tool and its features is beyond the scope of this book. For more information, see the resources listed below.

Making Useful Documentation Comments from the official Rust Programming Language documentation.

2.9. Vendoring Project Dependencies
Copy link

Vendoring project dependencies means creating a local copy of the dependencies for offline redistribution and reuse. Vendored dependencies can be used by the cargo build tool without any connection to the internet.

The cargo vendor command for vendoring dependencies is supplied by the cargo plug-in cargo-vendor.

To install cargo-vendor 0.1.23 :

For Red Hat Enterprise Linux 7:
```
yum install rust-toolset-1.35-cargo-vendor
```
```
# yum install rust-toolset-1.35-cargo-vendor
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
dnf install cargo-vendor
```
```
# dnf install cargo-vendor
```
Copy to Clipboard Toggle word wrap

To vendor dependencies for a cargo project, change to the project directory and run the cargo tool as follows:

For Red Hat Enterprise Linux 7:
```
scl enable rust-toolset-1.35 'cargo vendor'
```
```
$ scl enable rust-toolset-1.35 'cargo vendor'
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
cargo vendor
```
```
$ cargo vendor
```
Copy to Clipboard Toggle word wrap

This creates a directory vendor and downloads sources of all dependencies to this directory. Additional configuration steps are printed to command line.

The cargo vendor command gathers the dependencies for a platform-independent result. Dependency crates for all potential target platforms are downloaded.

Important

The cargo vendor command is an experimental, unofficial plug-in for the cargo tool.

Example 2.8. Vendoring Project Dependencies

This example assumes that you have successfully built the Rust project helloworld with dependencies, according to Example 2.6, “Adding Dependency to a Project and Building it with cargo”.

Change to the directory helloworld and run the cargo vendor command to vendor the project with dependencies:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'cargo vendor'
 Downloading kernel32-sys v0.2.2
 Downloading redox_syscall v0.1.31
 Downloading winapi-build v0.1.1
 Downloading winapi v0.2.8
   Vendoring kernel32-sys v0.2.2 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/kernel32-sys-0.2.2) to vendor/kernel32-sys
   Vendoring libc v0.2.32 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.32) to vendor/libc
   Vendoring redox_syscall v0.1.31 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/redox_syscall-0.1.31) to vendor/redox_syscall
   Vendoring time v0.1.38 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/time-0.1.38) to vendor/time
   Vendoring winapi v0.2.8 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/winapi-0.2.8) to vendor/winapi
   Vendoring winapi-build v0.1.1 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/winapi-build-0.1.1) to vendor/winapi-build
To use vendored sources, add this to your .cargo/config for this project:

    [source.crates-io]
    replace-with = "vendored-sources"

    [source.vendored-sources]
    directory = "/home/vslavik/helloworld/vendor"

$ scl enable rust-toolset-1.35 'cargo vendor'
 Downloading kernel32-sys v0.2.2
 Downloading redox_syscall v0.1.31
 Downloading winapi-build v0.1.1
 Downloading winapi v0.2.8
   Vendoring kernel32-sys v0.2.2 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/kernel32-sys-0.2.2) to vendor/kernel32-sys
   Vendoring libc v0.2.32 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.32) to vendor/libc
   Vendoring redox_syscall v0.1.31 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/redox_syscall-0.1.31) to vendor/redox_syscall
   Vendoring time v0.1.38 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/time-0.1.38) to vendor/time
   Vendoring winapi v0.2.8 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/winapi-0.2.8) to vendor/winapi
   Vendoring winapi-build v0.1.1 (/home/vslavik/.cargo/registry/src/github.com-1ecc6299db9ec823/winapi-build-0.1.1) to vendor/winapi-build
To use vendored sources, add this to your .cargo/config for this project:

    [source.crates-io]
    replace-with = "vendored-sources"

    [source.vendored-sources]
    directory = "/home/vslavik/helloworld/vendor"

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
cargo vendor
```
```
$ cargo vendor
```
Copy to Clipboard Toggle word wrap

Examine the result:

ls
Cargo.lock  Cargo.toml  src  target  vendor
tree vendor
vendor
├── kernel32-sys
│   ├── build.rs
│   ├── Cargo.toml
│   ├── README.md
│   └── src
│       └── lib.rs
├── libc
│   ├── appveyor.yml
│   ├── Cargo.toml
...
75 directories, 319 files

$ ls
Cargo.lock  Cargo.toml  src  target  vendor
$ tree vendor
vendor
├── kernel32-sys
│   ├── build.rs
│   ├── Cargo.toml
│   ├── README.md
│   └── src
│       └── lib.rs
├── libc
│   ├── appveyor.yml
│   ├── Cargo.toml
...
75 directories, 319 files

Copy to Clipboard

Toggle word wrap

The vendor directory contains copies of all the dependency crates needed to build the helloworld program. Note that the crates for building the project on the Windows operating system have been vendored, too, despite running this command on Red Hat Enterprise Linux.

Note

The tree tool is available from the default Red Hat Enterprise Linux repositories. To install it:

yum install tree

# yum install tree

Copy to Clipboard

Toggle word wrap

2.10. Additional Resources
Copy link

A detailed description of the cargo tool and its features is beyond the scope of this book. For more information, see the resources listed below.

Cargo Documentation

cargo(1) — The manual page for the cargo tool provides detailed information on its usage. To display the manual page for the version included in Rust Toolset:
- For Red Hat Enterprise Linux 7:
  $ scl enable rust-toolset-1.35 'man cargo'
  Copy to Clipboard Toggle word wrap
- For Red Hat Enterprise Linux 8:
  $ man cargo
  Copy to Clipboard Toggle word wrap
Cargo, Rust’s Package Manager HTML book is provided as a package:
- On Red Hat Enterprise Linux 7:
  # yum install rust-toolset-1.35-cargo-doc
  Copy to Clipboard Toggle word wrap
  The HTML is available at /opt/rh/rust-toolset-1.35/usr/share/doc/cargo/html/index.html
- On Red Hat Enterprise Linux 8:
  # yum install cargo-doc
  Copy to Clipboard Toggle word wrap
  The HTML is available at /usr/share/doc/cargo/html/index.html

Online Cargo Documentation

Official Cargo Guide

Chapter 3. rustfmt
Copy link

The rustfmt tool provides automatic formatting of Rust source code.

Rust Toolset is distributed with rustfmt 1.35.0.

3.1. Installing rustfmt
Copy link

For Red Hat Enterprise Linux 7:
```
yum install rust-toolset-1.35-rustfmt
```
```
# yum install rust-toolset-1.35-rustfmt
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
dnf install rustfmt
```
```
# dnf install rustfmt
```
Copy to Clipboard Toggle word wrap

3.2. Using rustfmt as a standalone tool
Copy link

To format a rust source file and all its dependencies with the rustfmt tool:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'rustfmt source-file'

$ scl enable rust-toolset-1.35 'rustfmt source-file'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
rustfmt source-file
```
```
$ rustfmt source-file
```
Copy to Clipboard Toggle word wrap

Replace source-file with path to the source file.

By default, rustfmt modifies the affected files in place without displaying details or creating backups. To change the behavior, use the --write-mode value option. For further details see the help mesage of rustfmt:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'rustfmt --help'

$ scl enable rust-toolset-1.35 'rustfmt --help'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
rustfmt --help
```
```
$ rustfmt --help
```
Copy to Clipboard Toggle word wrap

Additionally, rustfmt accepts standard input instead of a file and provides its output in standard output.

3.3. Using rustfmt with cargo
Copy link

To format all source files in a cargo crate:

For Red Hat Enterprise Linux 7:
```
scl enable rust-toolset-1.35 'cargo fmt'
```
```
$ scl enable rust-toolset-1.35 'cargo fmt'
```
Copy to Clipboard Toggle word wrap
For Red Hat Enterprise Linux 8:
```
cargo fmt
```
```
$ cargo fmt
```
Copy to Clipboard Toggle word wrap

To change the rustfmt formatting options, create the configuration file rustfmt.toml in the project directory and supply the configuration there. For further details see the help message of rustfmt:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'rustfmt --config-help'

$ scl enable rust-toolset-1.35 'rustfmt --config-help'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
rustfmt --config-help
```
```
$ rustfmt --config-help
```
Copy to Clipboard Toggle word wrap

3.4. Additional Resources
Copy link

Help messages of rustfmt:

For Red Hat Enterprise Linux 7:

scl enable rust-toolset-1.35 'rustfmt --help'
scl enable rust-toolset-1.35 'rustfmt --config-help'

$ scl enable rust-toolset-1.35 'rustfmt --help'
$ scl enable rust-toolset-1.35 'rustfmt --config-help'

Copy to Clipboard

Toggle word wrap

For Red Hat Enterprise Linux 8:
```
rustfmt --help
rustfmt --config-help
```
```
$ rustfmt --help
$ rustfmt --config-help
```
Copy to Clipboard Toggle word wrap

Configuring Rustfmt in Configurations.md:
- Location in Red Hat Enterprise Linux 7:
  /opt/rh/rust-toolset-1.35/usr/share/doc/rust-toolset-1.35-rustfmt-1.35.0/Configurations.md
- Location in Red Hat Enterprise Linux 8:
  /usr/share/doc/rustfmt/Configurations.md

Chapter 4. Container Image with Rust Toolset for RHEL 7
Copy link

The Rust Toolset is available as a container image which can be downloaded from Red Hat Container Registry.

4.1. Image Contents
Copy link

The devtools/rust-toolset-1.35-rhel7 image provides content corresponding to the following packages:

Expand

Component	Version	Package
`Rust`	1.35.0	rust-toolset-1.35-rust
`Cargo`	1.35.0	rust-toolset-1.35-cargo
`Vendor plug-in for Cargo`	0.1.23	rust-toolset-1.35-cargo-vendor

4.2. Access to the Image
Copy link

To pull the devtools/rust-toolset-1.35-rhel7 image, run the following command as root:

podman pull registry.access.redhat.com/devtools/rust-toolset-1.35-rhel7

# podman pull registry.access.redhat.com/devtools/rust-toolset-1.35-rhel7

Copy to Clipboard

Toggle word wrap

4.3. Additional Resources
Copy link

Rust Toolset 1.35.0 — entry in the Red Hat Container Catalog
Using Red Hat Software Collections Container Images

Chapter 5. Changes in Rust Toolset in Red Hat Developer Tools 2019.3
Copy link

This chapter lists some notable changes in Rust Toolset since its previous release.

5.1. Rust
Copy link

Rust has been updated from version 1.31.1 to 1.35.0. Notable changes include:

Changes for Rust 1.32:
- The dbg! macro: Enable easier print-debugging, with file, line, and an expression value.
- Final module improvements: "use" statements are more uniform. For example: allowing direct imports of enum variants.
- Macro improvements: Macros can now match on literal tokens, and the "?" operator matches exactly 0 or 1 repetitions.
- Library stabilizations: Integers support conversions to and from byte arrays.
Changes for Rust 1.33:
- const fn improvements: Implementing constant functions now supports destructuring patterns, let bindings, assignments, and more.
- Pinning: Provides type-level guarantees that an object in memory will not move.
- Import as _: Anonymous imports to bring trait methods in scope without the trait name, avoiding possible conflicts.
- Library stabilizations: Many more const methods for integers.
Changes for Rust 1.34:
- Alternative cargo registries: Allows using registries other than the public crates.io, possibly mixed together.
- ? in documentation tests: The Try operator can now be used in doc tests that specify their "return" type.
- TryFrom and TryInto: Provide fallible conversion methods.
- fn before_exec is deprecated in favor of unsafe fn pre_exec: Forked pre-exec environments have additional safety constraints, which is now indicated by being an unsafe call.
- Library stabilizations: Non-zero signed integer types, from_fn and successors iterator constructors.
Changes for Rust 1.35:
- Fn* closure traits implemented for Box<dyn Fn*>: Especially notable for Box<dyn FnOnce>, which wasn’t possible to call abstractly before.
- Calling dbg!() with no argument: Updated from 1.32, it can now print just the file:line if there’s no argument.
- Library stabilizations: float copysign, Range contains, RefCell map_split.

5.2. cargo
Copy link

The cargo tool has been updated from version 1.31.0 to 1.35.0.

5.3. cargo-vendor
Copy link

The cargo-vendor tool has been updated from version 0.1.22 to 0.1.23.

Legal Notice
Copy link

The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.

Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.

Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.

Linux® is the registered trademark of Linus Torvalds in the United States and other countries.

Java® is a registered trademark of Oracle and/or its affiliates.

XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.

MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.

Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.

The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.

All other trademarks are the property of their respective owners.

Using Rust Toolset

Installing and using Rust Toolset 1.35.0

Peter Macko

Kevin Owen

Vladimir Slavik

Chapter 1. Rust ToolsetCopy linkLink copied to clipboard!

1.1. About Rust ToolsetCopy linkLink copied to clipboard!

1.2. CompatibilityCopy linkLink copied to clipboard!

1.3. Getting Access to Rust Toolset on Red Hat Enterprise Linux 7Copy linkLink copied to clipboard!

Additional Resources

1.4. Installing Rust ToolsetCopy linkLink copied to clipboard!

1.5. Additional ResourcesCopy linkLink copied to clipboard!

Installable Documentation

Online Documentation

Chapter 2. cargoCopy linkLink copied to clipboard!

2.1. Installing cargoCopy linkLink copied to clipboard!

2.2. Creating a New ProjectCopy linkLink copied to clipboard!

2.3. Building a ProjectCopy linkLink copied to clipboard!

2.4. Checking a ProgramCopy linkLink copied to clipboard!

2.5. Running a ProgramCopy linkLink copied to clipboard!

2.6. Running Project TestsCopy linkLink copied to clipboard!

2.7. Configuring Project DependenciesCopy linkLink copied to clipboard!

Additional Resources

2.8. Building Project DocumentationCopy linkLink copied to clipboard!

Additional Resources

2.9. Vendoring Project DependenciesCopy linkLink copied to clipboard!

2.10. Additional ResourcesCopy linkLink copied to clipboard!

Cargo Documentation

Online Cargo Documentation

See Also

Chapter 3. rustfmtCopy linkLink copied to clipboard!

3.1. Installing rustfmtCopy linkLink copied to clipboard!

3.2. Using rustfmt as a standalone toolCopy linkLink copied to clipboard!

3.3. Using rustfmt with cargoCopy linkLink copied to clipboard!

3.4. Additional ResourcesCopy linkLink copied to clipboard!

Chapter 4. Container Image with Rust Toolset for RHEL 7Copy linkLink copied to clipboard!

4.1. Image ContentsCopy linkLink copied to clipboard!

4.2. Access to the ImageCopy linkLink copied to clipboard!

4.3. Additional ResourcesCopy linkLink copied to clipboard!

Chapter 5. Changes in Rust Toolset in Red Hat Developer Tools 2019.3Copy linkLink copied to clipboard!

5.1. RustCopy linkLink copied to clipboard!

5.2. cargoCopy linkLink copied to clipboard!

5.3. cargo-vendorCopy linkLink copied to clipboard!

Legal NoticeCopy linkLink copied to clipboard!

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

Making open source more inclusive

About Red Hat

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

Chapter 1. Rust Toolset
Copy link

1.1. About Rust Toolset
Copy link

1.2. Compatibility
Copy link

1.3. Getting Access to Rust Toolset on Red Hat Enterprise Linux 7
Copy link

1.4. Installing Rust Toolset
Copy link

1.5. Additional Resources
Copy link

Chapter 2. cargo
Copy link

2.1. Installing cargo
Copy link

2.2. Creating a New Project
Copy link

2.3. Building a Project
Copy link

2.4. Checking a Program
Copy link

2.5. Running a Program
Copy link

2.6. Running Project Tests
Copy link

2.7. Configuring Project Dependencies
Copy link

2.8. Building Project Documentation
Copy link

2.9. Vendoring Project Dependencies
Copy link

2.10. Additional Resources
Copy link

Chapter 3. rustfmt
Copy link

3.1. Installing rustfmt
Copy link

3.2. Using rustfmt as a standalone tool
Copy link

3.3. Using rustfmt with cargo
Copy link

3.4. Additional Resources
Copy link

Chapter 4. Container Image with Rust Toolset for RHEL 7
Copy link

4.1. Image Contents
Copy link

4.2. Access to the Image
Copy link

4.3. Additional Resources
Copy link

Chapter 5. Changes in Rust Toolset in Red Hat Developer Tools 2019.3
Copy link

5.1. Rust
Copy link

5.2. cargo
Copy link

5.3. cargo-vendor
Copy link

Legal Notice
Copy link