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 install_prereleases: Option<bool>,
    pub enforce_lock: Option<bool>,
    pub respect_binaries: Option<bool>,
    pub target_version: Option<VersionReq>,
    pub environment: Option<BTreeMap<String, EnvironmentOverride>>,
}

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.

§install_prereleases: Option<bool>

Whether to install pre-release versions.

§enforce_lock: Option<bool>

Whether to enforce Cargo.lock versions.

§respect_binaries: Option<bool>

Whether to install only the pre-configured binaries.

§target_version: Option<VersionReq>

Versions to constrain to.

§environment: Option<BTreeMap<String, EnvironmentOverride>>

Environment variables to alter for cargo. None to remove.

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::SetInstallPrereleases(false),
                                 ConfigOperation::SetEnforceLock(true),
                                 ConfigOperation::SetRespectBinaries(true),
                                 ConfigOperation::SetTargetVersion(VersionReq::from_str(">=0.1").unwrap()),
                                 ConfigOperation::SetEnvironment("RUSTC_WRAPPER".to_string(), "sccache".to_string()),
                                 ConfigOperation::ClearEnvironment("CC".to_string())]),
           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),
               enforce_lock: Some(true),
               respect_binaries: Some(true),
               target_version: Some(VersionReq::from_str(">=0.1").unwrap()),
               environment: Some({
                   let mut vars = BTreeMap::new();
                   vars.insert("RUSTC_WRAPPER".to_string(), EnvironmentOverride(Some("sccache".to_string())));
                   vars.insert("CC".to_string(), EnvironmentOverride(None));
                   vars
               }),
           });

source

pub fn cargo_args<S: AsRef<str>, I: IntoIterator<Item = S>>( &self, executables: I ) -> Vec<Cow<'static, str>>

Generate cargo arguments from this configuration.

Executable names are stripped of their trailing ".exe", if any.

§Examples

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

source

pub fn environmentalise<'c>(&self, cmd: &'c mut Command) -> &'c mut Command

Apply transformations from self.environment to cmd.

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

source

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

Read a configset from the specified file.

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

§Examples

fs::write(&config_file, &b"\
   [cargo-update]\n\
   default_features = true\n\
   features = [\"serde\"]\n"[..]).unwrap();
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,
        enforce_lock: None,
        respect_binaries: None,
        target_version: None,
        environment: None,
    });
    pkgs
}));

source

pub fn write( configuration: &BTreeMap<String, PackageConfig>, p: &Path ) -> Result<(), (String, 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,
        enforce_lock: None,
        respect_binaries: None,
        target_version: None,
        environment: None,
    });
    pkgs
}, &config_file).unwrap();

assert_eq!(&fs::read_to_string(&config_file).unwrap(),
           "[cargo-update]\n\
            default_features = true\n\
            features = [\"serde\"]\n");