specfold-core 0.2.5

Library behind specfold: typed Markdown documents, owners, a derived graph and checks.
Documentation 
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

//! Every write is planned first and applied only on request, so a preview and the real run do
//! exactly the same thing.

use anyhow::{Context, Result};
use serde::Serialize;
use std::path::Path;

#[derive(Debug, Clone, Serialize)]
#[serde(tag = "op", rename_all = "lowercase")]
pub enum Change {
    Write {
        path: String,
        content: String,
        created: bool,
    },
    Move {
        from: String,
        to: String,
    },
    /// Copies bytes from a source file (attachments during an import).
    Copy {
        from: String,
        to: String,
    },
    Remove {
        path: String,
    },
}

#[derive(Debug, Clone, Default, Serialize)]
pub struct Plan {
    pub changes: Vec<Change>,
}

impl Plan {
    pub fn write(&mut self, path: impl Into<String>, content: String, created: bool) {
        let path = path.into();
        self.changes.retain(|c| !matches!(c, Change::Write { path: p, .. } if *p == path));
        self.changes.push(Change::Write { path, content, created });
    }

    pub fn mv(&mut self, from: impl Into<String>, to: impl Into<String>) {
        self.changes.push(Change::Move { from: from.into(), to: to.into() });
    }

    pub fn copy(&mut self, from: impl Into<String>, to: impl Into<String>) {
        self.changes.push(Change::Copy { from: from.into(), to: to.into() });
    }

    pub fn remove(&mut self, path: impl Into<String>) {
        self.changes.push(Change::Remove { path: path.into() });
    }

    pub fn is_empty(&self) -> bool {
        self.changes.is_empty()
    }

    /// Paths touched, for reports.
    pub fn paths(&self) -> Vec<String> {
        self.changes
            .iter()
            .map(|c| match c {
                Change::Write { path, .. } | Change::Remove { path } => path.clone(),
                Change::Move { from, to } | Change::Copy { from, to } => format!("{from} -> {to}"),
            })
            .collect()
    }

    /// Moves and copies first (so writes land at the new paths), then writes, then removals.
    pub fn apply(&self, root: &Path) -> Result<()> {
        let ensure_parent = |p: &Path| -> Result<()> {
            if let Some(d) = p.parent() {
                std::fs::create_dir_all(d)?;
            }
            Ok(())
        };
        for c in &self.changes {
            match c {
                Change::Move { from, to } => {
                    let dst = root.join(to);
                    ensure_parent(&dst)?;
                    std::fs::rename(root.join(from), &dst).with_context(|| format!("cannot move {from} to {to}"))?;
                }
                Change::Copy { from, to } => {
                    let dst = root.join(to);
                    ensure_parent(&dst)?;
                    std::fs::copy(root.join(from), &dst).with_context(|| format!("cannot copy {from} to {to}"))?;
                }
                _ => {}
            }
        }
        for c in &self.changes {
            if let Change::Write { path, content, .. } = c {
                let dst = root.join(path);
                ensure_parent(&dst)?;
                std::fs::write(&dst, content).with_context(|| format!("cannot write {path}"))?;
            }
        }
        for c in &self.changes {
            if let Change::Remove { path } = c {
                let p = root.join(path);
                if p.is_dir() {
                    std::fs::remove_dir_all(&p).with_context(|| format!("cannot remove {path}"))?;
                } else if p.exists() {
                    std::fs::remove_file(&p).with_context(|| format!("cannot remove {path}"))?;
                }
            }
        }
        Ok(())
    }
}