Struct Dependency 

pub struct Dependency { /* private fields */ }

Represents a single dependency

Implementations

impl Dependency

pub fn repo(label: &str, repo: &str) -> Dependency

Constructs a Depedency that points to a git repo

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::repo("foo", "https://github.com/foo/bar");
// translates to:
// [dependencies]
// foo = { git = "https://github.com/foo/bar" }

pub fn version(label: &str, version: &str) -> Dependency

Constructs a Depedency that specifies a semver version

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::version("foo", "0.1.0");
// translates to:
// [dependencies]
// foo = "0.1.0"

pub fn path(label: &str, path: &str) -> Dependency

Constructs a Depedency that points to a path

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::path("foo", "/path/to/foo");
// translates to:
// [dependencies]
// foo = { path = "/path/to/foo" }

pub fn rev(label: &str, repo: &str, rev: &str) -> Dependency

Constructs a Depedency that points to a specific revision of a repository

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::rev("foo", "https://github.com/foo/bar", "0a14cbe3928");
// translates to:
// [dependencies]
// foo = { git = "https://github.com/foo/bar", rev = "0a14cbe3928" }

pub fn tag(label: &str, repo: &str, tag: &str) -> Dependency

Constructs a Depedency that points to a specific tag of a repository

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::tag("foo", "https://github.com/foo/bar", "v1.0.0");
// translates to:
// [dependencies]
// foo = { git = "https://github.com/foo/bar", tag = "v1.0.0" }

pub fn branch(label: &str, repo: &str, branch: &str) -> Dependency

Constructs a Depedency that points to a specific branch of a repository

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::branch("foo", "https://github.com/foo/bar", "some-branch");
// translates to:
// [dependencies]
// foo = { git = "https://github.com/foo/bar", branch = "some-branch" }

pub fn build(&self) -> Self

If the builder pattern has been used to construct this Dependency, this takes ownership

pub fn optional(&mut self, optional: bool) -> &mut Self

Mark this dependency as “optional = true”

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::version("foo", "0.1.0")
                     .optional(true)
                     .build();
// translates to:
// [dependencies]
// foo = { version = "0.1.0", optional = true }

pub fn default_features(&mut self, default_features: bool) -> &mut Self

Specify whether this dependency is using the default features or not

Example

extern crate cargo_toml_builder;
use cargo_toml_builder::prelude::*;
let dep = Dependency::version("foo", "0.1.0")
                     .default_features(false)
                     .build();
// translates to:
// [dependencies]
// foo = { version = "0.1.0", default-features = false }

Trait Implementations

impl Clone for Dependency

fn clone(&self) -> Dependency

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dependency

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

Formats the value using the given formatter.

impl<'a> From<&'a Dependency> for Dependency

fn from(d: &Dependency) -> Dependency

Converts to this type from the input type.

impl<'a> From<&'a Dependency> for InlineTable

fn from(dep: &'a Dependency) -> InlineTable

Converts to this type from the input type.

impl<'a> From<&'a Dependency> for Table

fn from(dep: &'a Dependency) -> Table

Converts to this type from the input type.

impl<'a> From<&'a mut Dependency> for Dependency

fn from(d: &'a mut Dependency) -> Dependency

Converts to this type from the input type.

impl<'a> From<&'a str> for Dependency

fn from(s: &'a str) -> Dependency

Converts to this type from the input type.

impl From<Dependency> for InlineTable

fn from(d: Dependency) -> InlineTable

Converts to this type from the input type.

impl From<String> for Dependency

fn from(s: String) -> Dependency

Converts to this type from the input type.

impl PartialEq for Dependency

fn eq(&self, other: &Dependency) -> 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 StructuralPartialEq for Dependency