Struct Manifest 

pub struct Manifest<Metadata = Value> {

    pub package: Option<Package<Metadata>>,
    pub workspace: Option<Workspace<Metadata>>,
    pub dependencies: BTreeMap<String, Dependency>,
    pub dev_dependencies: BTreeMap<String, Dependency>,
    pub build_dependencies: BTreeMap<String, Dependency>,
    pub target: BTreeMap<String, Target>,
    pub features: BTreeMap<String, Vec<String>>,
    pub replace: BTreeMap<String, Dependency>,
    pub patch: BTreeMap<String, BTreeMap<String, Dependency>>,
    pub lib: Option<Product>,
    pub profile: Profiles,
    pub badges: Badges,
    pub bin: Vec<Product>,
    pub bench: Vec<Product>,
    pub test: Vec<Product>,
    pub example: Vec<Product>,
    pub lints: Option<Lints>,
}

The top-level Cargo.toml structure. This is the main type in this library.

The Metadata is a generic type for [package.metadata] table. You can replace it with your own struct type if you use the metadata and don’t want to use the catch-all Value type.

Fields

package: Option<Package<Metadata>>

Package definition (a cargo crate)

workspace: Option<Workspace<Metadata>>

Workspace-wide settings

dependencies: BTreeMap<String, Dependency>

Normal dependencies

dev_dependencies: BTreeMap<String, Dependency>

Dev/test-only deps

build_dependencies: BTreeMap<String, Dependency>

Build-time deps

target: BTreeMap<String, Target>

[target.cfg.dependencies]

features: BTreeMap<String, Vec<String>>

The [features] section. This set may be incomplete!

Optional dependencies may create implied Cargo features. This features section also supports microsyntax with dep:, /, and ? for managing dependencies and their features.io

This crate has an optional [features] module for dealing with this complexity and getting the real list of features.

replace: BTreeMap<String, Dependency>

👎Deprecated: Cargo recommends patch instead

Obsolete

patch: BTreeMap<String, BTreeMap<String, Dependency>>

[patch.crates-io] section

lib: Option<Product>

Note that due to autolibs feature this is not the complete list unless you run Manifest::complete_from_path

profile: Profiles

Compilation/optimization settings

badges: Badges

[badges] section

bin: Vec<Product>

Note that due to autobins feature this is not the complete list unless you run Manifest::complete_from_path

bench: Vec<Product>

Benchmarks

test: Vec<Product>

Integration tests

example: Vec<Product>

Examples

lints: Option<Lints>

Lints

Implementations

impl Manifest

pub fn from_path(cargo_toml_path: impl AsRef<Path>) -> Result<Manifest, Error>

Parse contents from a Cargo.toml file on disk.

Calls Manifest::complete_from_path to discover implicit binaries, etc. If needed, it will search the file system for a workspace, and fill in data inherited from the workspace.

pub fn from_slice(cargo_toml_content: &[u8]) -> Result<Manifest, Error>

Warning: this will make an incomplete manifest, which will be missing data and panic when using workspace inheritance.

Parse contents of a Cargo.toml file already loaded as a byte slice. It’s not a file name, but file’s TOML-syntax content.

If you don’t call Manifest::complete_from_path, it may be missing implicit data, and panic if workspace inheritance is used.

pub fn from_str(cargo_toml_content: &str) -> Result<Manifest, Error>

Warning: this will make an incomplete manifest, which will be missing data and panic when using workspace inheritance.

It parses contents of a Cargo.toml file loaded as a string. It’s not a file name, but file’s TOML-syntax content.

For a more reliable method, see from_path.

If you don’t call Manifest::complete_from_path, it may be missing implicit data, and panic if workspace inheritance is used.

impl<Metadata> Manifest<Metadata>

where Metadata: for<'a> Deserialize<'a>,

pub fn from_slice_with_metadata( cargo_toml_content: &[u8], ) -> Result<Manifest<Metadata>, Error>

Warning: this will make an incomplete manifest, which will be missing data and panic when using workspace inheritance.

Parse Cargo.toml, and parse its [package.metadata] into a custom Serde-compatible type.

It does not call Manifest::complete_from_path, so may be missing implicit data.

pub fn from_path_with_metadata<P>( cargo_toml_path: P, ) -> Result<Manifest<Metadata>, Error>

where P: AsRef<Path>,

Parse contents from Cargo.toml file on disk, with custom Serde-compatible metadata type.

Calls Manifest::complete_from_path, so it will load a workspace if necessary.

impl<Metadata> Manifest<Metadata>

pub fn complete_from_path(&mut self, path: &Path) -> Result<(), Error>

Cargo.toml doesn’t contain explicit information about [lib] and [[bin]], which are inferred based on files on disk.

This scans the disk to make the data in the manifest as complete as possible.

It supports workspace inheritance and will search for a root workspace. Use Manifest::complete_from_path_and_workspace to provide the workspace explicitly.

pub fn complete_from_path_and_workspace<PackageMetadataTypeDoesNotMatterHere>( &mut self, package_manifest_path: &Path, workspace_manifest_and_path: Option<(&Manifest<PackageMetadataTypeDoesNotMatterHere>, &Path)>, ) -> Result<(), Error>

Manifest::complete_from_path, but allows passing workspace manifest explicitly.

workspace_manifest_and_path is the root workspace manifest already parsed, and the path is the path to the root workspace’s directory. If it’s None, the root workspace will be discovered automatically.

pub fn complete_from_abstract_filesystem<PackageMetadataTypeDoesNotMatterHere, Fs>( &mut self, fs: Fs, workspace_manifest_and_path: Option<(&Manifest<PackageMetadataTypeDoesNotMatterHere>, &Path)>, ) -> Result<(), Error>

where Fs: AbstractFilesystem,

Cargo.toml doesn’t contain explicit information about [lib] and [[bin]], which are inferred based on files on disk.

You can provide any implementation of directory scan, which doesn’t have to be reading straight from disk (might scan a tarball or a git repo, for example).

If workspace_manifest_and_path is set, it will inherit from this workspace. If it’s None, it will try to find a workspace if needed.

Call it like complete_from_abstract_filesystem::<cargo_toml::Value, _>(…) if the arguments are ambiguous.

pub fn needs_workspace_inheritance(&self) -> bool

If true, some fields are unavailable. If false, it’s fully usable as-is.

It is false in manifests that use workspace inheritance, but had their data completed from the root manifest already.

pub fn package(&self) -> &Package<Metadata>

Panics if it’s not a package (only a workspace).

You can access the .package field directly to handle the Option:

manifest.package.as_ref().ok_or(SomeError::NotAPackage)?;

Trait Implementations

impl<Metadata> Clone for Manifest<Metadata>

where Metadata: Clone,

fn clone(&self) -> Manifest<Metadata>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Metadata> Debug for Manifest<Metadata>

where Metadata: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<Metadata> Default for Manifest<Metadata>

where Metadata: Default,

fn default() -> Manifest<Metadata>

Returns the “default value” for a type.

impl<'de, Metadata> Deserialize<'de> for Manifest<Metadata>

where Metadata: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Manifest<Metadata>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Metadata> PartialEq for Manifest<Metadata>

where Metadata: PartialEq,

fn eq(&self, other: &Manifest<Metadata>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Metadata> Serialize for Manifest<Metadata>

where Metadata: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Metadata> StructuralPartialEq for Manifest<Metadata>