Struct cargo_update::ops::PackageConfig

pub struct PackageConfig {
    pub toolchain: Option<String>,
    pub default_features: bool,
    pub features: BTreeSet<String>,
    pub debug: Option<bool>,
    pub install_prereleases: Option<bool>,
    pub target_version: Option<VersionReq>,
}

Compilation configuration for one crate.

Examples

Reading a configset, adding an entry to it, then writing it back.

let mut configuration = PackageConfig::read(&config_file).unwrap();
configuration.insert("cargo_update".to_string(), PackageConfig::from(&operations));
PackageConfig::write(&configuration, &config_file).unwrap();

Fields

toolchain: Option<String>

Toolchain to use to compile the package, or None for default.

default_features: bool

Whether to compile the package with the default features.

features: BTreeSet<String>

Features to compile the package with.

debug: Option<bool>

Whether to compile in debug mode.

install_prereleases: Option<bool>

Whether to install pre-release versions.

target_version: Option<VersionReq>

Versions to constrain to.

Methods

impl PackageConfig

pub fn from<'o, O: IntoIterator<Item = &'o ConfigOperation>>(
    ops: O
) -> PackageConfig

Create a package config based on the default settings and modified according to the specified operations.

Examples

assert_eq!(PackageConfig::from(&[ConfigOperation::SetToolchain("nightly".to_string()),
                                 ConfigOperation::DefaultFeatures(false),
                                 ConfigOperation::AddFeature("rustc-serialize".to_string()),
                                 ConfigOperation::SetDebugMode(true),
                                 ConfigOperation::SetInstallPrereleases(false),
                                 ConfigOperation::SetTargetVersion(VersionReq::from_str(">=0.1").unwrap())]),
           PackageConfig {
               toolchain: Some("nightly".to_string()),
               default_features: false,
               features: {
                   let mut feats = BTreeSet::new();
                   feats.insert("rustc-serialize".to_string());
                   feats
               },
               debug: Some(true),
               install_prereleases: Some(false),
               target_version: Some(VersionReq::from_str(">=0.1").unwrap()),
           });

pub fn cargo_args(&self) -> Vec<String>

Generate cargo arguments from this configuration.

Examples

let cmd = Command::new("cargo").args(configuration.get(&name).unwrap().cargo_args()).arg(&name)
// Process the command further -- run it, for example.

pub fn execute_operations<'o, O: IntoIterator<Item = &'o ConfigOperation>>(
    &mut self,
    ops: O
)

Modify self according to the specified set of operations.

Examples

let mut cfg = PackageConfig {
    toolchain: Some("nightly".to_string()),
    default_features: false,
    features: {
        let mut feats = BTreeSet::new();
        feats.insert("rustc-serialize".to_string());
        feats
    },
    debug: None,
    install_prereleases: None,
    target_version: Some(VersionReq::from_str(">=0.1").unwrap()),
};
cfg.execute_operations(&[ConfigOperation::RemoveToolchain,
                         ConfigOperation::AddFeature("serde".to_string()),
                         ConfigOperation::RemoveFeature("rustc-serialize".to_string()),
                         ConfigOperation::SetDebugMode(true),
                         ConfigOperation::RemoveTargetVersion]);
assert_eq!(cfg,
           PackageConfig {
               toolchain: None,
               default_features: false,
               features: {
                   let mut feats = BTreeSet::new();
                   feats.insert("serde".to_string());
                   feats
               },
               debug: Some(true),
               install_prereleases: None,
               target_version: None,
           });

pub fn read(p: &Path) -> Result<BTreeMap<String, PackageConfig>, i32>

Read a configset from the specified file.

If the specified file doesn't exist an empty configset is returned.

Examples

File::create(&config_file).unwrap().write_all(&b"\
   [cargo-update]\n\
   default_features = true\n\
   features = [\"serde\"]\n"[..]);
assert_eq!(PackageConfig::read(&config_file), Ok({
    let mut pkgs = BTreeMap::new();
    pkgs.insert("cargo-update".to_string(), PackageConfig {
        toolchain: None,
        default_features: true,
        features: {
            let mut feats = BTreeSet::new();
            feats.insert("serde".to_string());
            feats
        },
        debug: None,
        install_prereleases: None,
        target_version: None,
    });
    pkgs
}));

pub fn write(
    configuration: &BTreeMap<String, PackageConfig>,
    p: &Path
) -> Result<(), i32>

Save a configset to the specified file.

Examples

PackageConfig::write(&{
    let mut pkgs = BTreeMap::new();
    pkgs.insert("cargo-update".to_string(), PackageConfig {
        toolchain: None,
        default_features: true,
        features: {
            let mut feats = BTreeSet::new();
            feats.insert("serde".to_string());
            feats
        },
        debug: None,
        install_prereleases: None,
        target_version: None,
    });
    pkgs
}, &config_file).unwrap();

let mut buf = String::new();
File::open(&config_file).unwrap().read_to_string(&mut buf).unwrap();
assert_eq!(&buf, "[cargo-update]\n\
                  default_features = true\n\
                  features = [\"serde\"]\n");

Trait Implementations

impl Clone for PackageConfig

fn clone(&self) -> PackageConfig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for PackageConfig

fn default() -> PackageConfig

Returns the "default value" for a type.

impl Eq for PackageConfig

impl Ord for PackageConfig

fn cmp(&self, other: &PackageConfig) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<PackageConfig> for PackageConfig

fn eq(&self, other: &PackageConfig) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<PackageConfig> for PackageConfig

fn partial_cmp(&self, other: &PackageConfig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &PackageConfig) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &PackageConfig) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &PackageConfig) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &PackageConfig) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Debug for PackageConfig

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

Formats the value using the given formatter.

impl Hash for PackageConfig

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl StructuralPartialEq for PackageConfig

impl StructuralEq for PackageConfig

impl Serialize for PackageConfig

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for PackageConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.