deadwiki 0.1.27

dead simple personal wiki
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

//! Braindead git sync:
//!   git add .
//!   git commit -am update
//!   git pull origin master
//!   git push origin master

use std::{fs, io, path::Path, thread, time};

/// How many seconds to wait before syncing.
const SYNC_WAIT: u64 = 30;

/// Start the syncing service.
pub fn start(root: &str) -> io::Result<()> {
    if !is_git_repo(root) {
        return Err(io::Error::new(
            io::ErrorKind::NotFound,
            format!("{} is not a git repo", root),
        ));
    }

    println!("~> running sync service");
    let root = root.to_string();
    thread::spawn(move || sync_periodically(&root));
    Ok(())
}

/// Is this wiki a git repo?
fn is_git_repo(root: &str) -> bool {
    let dir = format!("{}.git", root);
    let path = Path::new(&dir);
    if let Ok(file) = fs::File::open(path) {
        if let Ok(meta) = file.metadata() {
            return meta.is_dir();
        }
    }
    false
}

/// Run the sync and then sleep.
fn sync_periodically(root: &str) -> io::Result<()> {
    // set current dir to wiki
    let period = time::Duration::from_millis(SYNC_WAIT * 1000);
    loop {
        save_changes(root)?;
        sync_changes(root)?;
        thread::sleep(period);
    }
}

macro_rules! git {
    ($root:expr, $($arg:expr),+) => {
        git($root, &[$($arg),+])
    };
}

/// Try to add and commit any new or modified wiki pages.
fn save_changes(root: &str) -> io::Result<bool> {
    let pending = git!(root, "status", "-s")?;
    if pending.is_empty() {
        return Ok(false);
    }

    // get a list of files that changed
    let changes = pending
        .split('\n')
        .map(|file| if file.len() > 3 { &file[3..] } else { file }.trim())
        .filter(|f| !f.is_empty())
        .collect::<Vec<_>>();
    let status = changes.join(if changes.len() == 1 { "" } else { ", " });

    println!("~> saving changes: {}", status);
    git!(root, "add", ".")?;
    git!(root, "commit", "-am", &status)?;
    Ok(true)
}

fn sync_changes(root: &str) -> io::Result<bool> {
    println!("~> syncing changes");
    git!(root, "pull", "origin", "master")?;
    git!(root, "push", "origin", "master")?;
    Ok(true)
}

fn git(root: &str, args: &[&str]) -> io::Result<String> {
    shell!(
        "git --git-dir {root}.git --work-tree {root} {args}",
        root = root,
        args = args.join(" ")
    )
}