Struct cargo_update::ops::PackageConfig

source ·

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

Expand description

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.

target_version: Option<VersionReq>

Whether to compile in debug mode.

Implementations

source

impl PackageConfig

source

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::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),
               target_version: Some(VersionReq::from_str(">=0.1").unwrap()),
           });

source

pub fn cargo_args(&self) -> Vec<String>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

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.

source

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,
    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),
               target_version: None,
           });

source

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,
        target_version: None,
    });
    pkgs
}));

source

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,
        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");