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

//! Parser for `Cargo.lock` files

pub(crate) mod encoding;
pub mod version;

pub use self::version::ResolveVersion;

use self::encoding::EncodableLockfile;
use crate::{
    error::{Error, ErrorKind},
    metadata::Metadata,
    package::Package,
    patch::Patch,
};
use std::{fs, path::Path, str::FromStr, string::ToString};

#[cfg(feature = "dependency-tree")]
use crate::dependency::Tree;

/// Parsed Cargo.lock file containing dependencies
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Lockfile {
    /// Version of the Lockfile
    pub version: ResolveVersion,

    /// Dependencies enumerated in the lockfile
    pub packages: Vec<Package>,

    /// Legacy "root" dependency for backwards compatibility
    pub root: Option<Package>,

    /// Package metadata
    pub metadata: Metadata,

    /// Patches
    pub patch: Patch,
}

impl Lockfile {
    /// Load lock data from a `Cargo.lock` file
    pub fn load(path: impl AsRef<Path>) -> Result<Self, Error> {
        match fs::read_to_string(path.as_ref()) {
            Ok(s) => s.parse(),
            Err(e) => fail!(
                ErrorKind::Io,
                "couldn't open {}: {}",
                path.as_ref().display(),
                e
            ),
        }
    }

    /// Get the dependency tree for this `Lockfile`. Returns an error if the
    /// contents of this lockfile aren't well structured.
    ///
    /// The `dependency-tree` Cargo feature must be enabled to use this.
    #[cfg(feature = "dependency-tree")]
    pub fn dependency_tree(&self) -> Result<Tree, Error> {
        Tree::new(self)
    }
}

impl FromStr for Lockfile {
    type Err = Error;

    fn from_str(toml_string: &str) -> Result<Self, Error> {
        Ok(toml::from_str(toml_string)?)
    }
}

impl ToString for Lockfile {
    fn to_string(&self) -> String {
        EncodableLockfile::from(self).to_string()
    }
}