1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::models::{CargoCrate, CrateId, DepGraph};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::{
    cmp::{self, Eq, Ord, PartialEq, PartialOrd},
    collections::BTreeSet,
    path::PathBuf,
};

static ID_CTR: AtomicUsize = AtomicUsize::new(0);

/// A crate in a cargo workspace
///
/// Has a name, path (stored as the offset of the root), and set of
/// dependencies inside the workspace.  To get the dependents of this
/// crate, query the dependency graph with the set of other crate IDs.
#[derive(Clone, Debug)]
pub struct Crate {
    /// Numeric Id of this crate
    pub id: CrateId,
    /// Package name, not the folder name
    pub name: String,
    /// Path offset of the workspace root
    pub cc: CargoCrate,
    /// List of dependencies this crate has inside this workspace
    pub dependencies: BTreeSet<CrateId>,
}

impl PartialEq for Crate {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Eq for Crate {}

impl Ord for Crate {
    fn cmp(&self, other: &Self) -> cmp::Ordering {
        self.id.cmp(&other.id)
    }
}

impl PartialOrd for Crate {
    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
        Some(self.cmp(other))
    }
}

/// Increment the monotonicly increasing Id
fn incr_id() -> usize {
    ID_CTR.fetch_add(1, Ordering::Relaxed)
}

impl Crate {
    pub fn new(cc: CargoCrate) -> Self {
        Self {
            id: incr_id(),
            name: cc.name(),
            cc,
            dependencies: BTreeSet::default(),
        }
    }

    /// Call this function once all crates have been loaded into scope
    pub fn process(&mut self, g: &DepGraph) {
        let deps: Vec<_> = self
            .cc
            .dependencies
            .iter()
            .filter_map(|d| g.find_crate(&d.name))
            .collect();

        deps.into_iter().for_each(|cid| self.add_dependency(cid));
    }

    /// Get the crate name
    pub fn name(&self) -> &String {
        &self.name
    }

    /// Get the crate path
    pub fn path(&self) -> &PathBuf {
        &self.cc.path
    }

    /// Get the current version
    pub fn version(&self) -> String {
        self.cc.version()
    }

    /// Add a dependency of this crate
    pub fn add_dependency(&mut self, id: CrateId) {
        self.dependencies.insert(id);
    }

    /// Check if this crate has a particular dependency
    pub fn has_dependency(&self, id: CrateId) -> bool {
        self.dependencies.contains(&id)
    }

    pub fn change_dependency(&mut self, dep: &String, new_ver: &String) {
        self.cc.change_dep(dep, new_ver);
    }

    /// Publish a new version of this crate
    pub fn publish(&mut self, new_version: String) {
        self.cc.set_version(new_version);
    }

    pub fn sync(&mut self) {
        self.cc.sync();
    }
}