changesette 0.1.0

A version and changelog manager for single-package applications, using the changesets file format
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::{
    fs, io,
    path::{Path, PathBuf},
};

use anyhow::{Context, Result};
use jsonc_parser::{
    ParseOptions,
    cst::{CstRootNode, CstStringLit},
};

use crate::package_json::{set_string_value, string_prop};

/// A loaded `package-lock.json`. Saving preserves the original formatting,
/// changing only the rewritten values.
pub(crate) struct PackageLock {
    path: PathBuf,
    root: CstRootNode,
    version_lits: Vec<CstStringLit>,
}

impl PackageLock {
    /// Loads `package-lock.json` under `dir`; a missing file yields
    /// `Ok(None)`.
    pub(crate) fn load(dir: &Path) -> Result<Option<Self>> {
        let path = dir.join("package-lock.json");
        let text = match fs::read_to_string(&path) {
            Ok(text) => text,
            Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(None),
            Err(err) => return Err(err).context(path.display().to_string()),
        };
        Self::parse(path, &text)
            .context("package-lock.json")
            .map(Some)
    }

    fn parse(path: PathBuf, text: &str) -> Result<Self> {
        let root = CstRootNode::parse(text, &ParseOptions::default())?;
        let object = root
            .object_value()
            .context("the root value must be an object")?;

        let mut version_lits = Vec::new();
        if let Some(lit) = string_prop(&object, "version", "top-level \"version\"")? {
            version_lits.push(lit);
        }
        if let Some(root_entry) = object
            .object_value("packages")
            .and_then(|packages| packages.object_value(""))
            && let Some(lit) = string_prop(&root_entry, "version", "packages.\"\".version")?
        {
            version_lits.push(lit);
        }

        Ok(Self {
            path,
            root,
            version_lits,
        })
    }

    /// Sets the top-level `version` and the `packages.""` entry's `version`,
    /// whichever are present.
    pub(crate) fn set_version(&mut self, version: &semver::Version) -> Result<()> {
        for lit in &self.version_lits {
            set_string_value(lit, &version.to_string());
        }
        Ok(())
    }

    /// Writes the possibly modified text back to the file it was loaded from.
    pub(crate) fn save(&self) -> Result<()> {
        fs::write(&self.path, self.root.to_string())
            .with_context(|| self.path.display().to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn fixture(case: &str) -> PathBuf {
        Path::new("tests/fixtures/package-lock").join(case)
    }

    fn rewrite(case: &str) -> String {
        let dir = tempfile::tempdir().unwrap();
        fs::copy(
            fixture(case).join("package-lock.json"),
            dir.path().join("package-lock.json"),
        )
        .unwrap();
        let mut package_lock = PackageLock::load(dir.path()).unwrap().unwrap();
        package_lock
            .set_version(&semver::Version::new(10, 1, 0))
            .unwrap();
        package_lock.save().unwrap();
        fs::read_to_string(dir.path().join("package-lock.json")).unwrap()
    }

    fn load_err(case: &str) -> String {
        format!("{:#}", PackageLock::load(&fixture(case)).err().unwrap())
    }

    #[test]
    fn rewrites_both_version_fields_of_a_v3_lockfile() {
        insta::assert_snapshot!(rewrite("v3"));
    }

    #[test]
    fn rewrites_only_the_top_level_version_of_a_v1_lockfile() {
        insta::assert_snapshot!(rewrite("v1"));
    }

    #[test]
    fn returns_none_when_the_file_does_not_exist() {
        assert!(PackageLock::load(&fixture("absent")).unwrap().is_none());
    }

    #[test]
    fn rejects_a_non_object_root() {
        insta::assert_snapshot!(load_err("root-not-object"));
    }

    #[test]
    fn rejects_a_non_string_version() {
        insta::assert_snapshot!(load_err("version-not-string"));
    }
}