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 enforce_lock: Option<bool>,
    pub respect_binaries: 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.

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.

Implementations

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::SetEnforceLock(true),
                                 ConfigOperation::SetRespectBinaries(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),
               install_prereleases: Some(false),
               enforce_lock: Some(true),
               respect_binaries: Some(true),
               target_version: Some(VersionReq::from_str(">=0.1").unwrap()),
           });

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.

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()),
};
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,
           });

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

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,
    });
    pkgs
}, &config_file).unwrap();

assert_eq!(&fs::read_to_string(&config_file).unwrap(),
           "[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 Debug for PackageConfig

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

Formats the value using the given formatter.

impl Default for PackageConfig

fn default() -> PackageConfig

Returns the “default value” for a type.

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.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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: &Rhs) -> bool

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

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 Eq for PackageConfig

impl StructuralEq for PackageConfig

impl StructuralPartialEq for PackageConfig