ddoc 0.18.0

doc site generator
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

use {
    crate::*,
    serde::de::DeserializeOwned,
    std::{
        fs::{
            self,
            File,
        },
        io::BufReader,
        path::Path,
    },
};

/// Deserialize an object from a JSON, TOML, or HJSON file.
///
/// # Errors
/// Return `DdError::Read` on file read errors, `DdError::UnsupportedFileFormat`
/// if the file extension is not supported, and deserialization errors
/// as appropriate.
pub fn read_file<T, P: AsRef<Path>>(path: P) -> DdResult<T>
where
    T: DeserializeOwned,
{
    let path = path.as_ref();
    let file = File::open(path).map_err(|error| DdError::Read {
        path: path.to_owned(),
        error,
    })?;
    let reader = BufReader::new(file);
    let obj = match path.extension().and_then(|s| s.to_str()) {
        Some("hjson") => deser_hjson::from_reader(reader)?,
        Some("json") => serde_json::from_reader(reader)?,
        Some("toml") => {
            let toml = std::io::read_to_string(reader)?;
            toml::from_str(&toml)?
        }
        _ => return Err(DdError::UnsupportedFileFormat(path.to_owned())),
    };
    Ok(obj)
}

/// Search direct subdirectories of `parent` for a ddoc project
/// (a directory containing a valid `ddoc.hjson` file).
pub fn project_subdirectory(parent: &Path) -> Option<std::path::PathBuf> {
    let read_dir = std::fs::read_dir(parent).ok()?;
    for entry in read_dir.flatten() {
        let path = entry.path();
        if path.is_dir() && Project::load(&path).is_ok() {
            return Some(path);
        }
    }
    None
}

/// Copy normal non hidden files from `src_dir` to `dst_dir` recursively
pub fn copy_normal_recursive(
    src_dir: &Path,
    dst_dir: &Path,
) -> DdResult<()> {
    if !dst_dir.exists() {
        fs::create_dir_all(dst_dir)?;
    }
    for entry in fs::read_dir(src_dir)? {
        let entry = entry?;
        let file_type = entry.file_type()?;
        if file_type.is_dir() {
            let sub_src = entry.path();
            let sub_dst = dst_dir.join(entry.file_name());
            copy_normal_recursive(&sub_src, &sub_dst)?;
            continue;
        }
        if !file_type.is_file() {
            continue;
        }
        let file_name = entry.file_name();
        let Some(file_name) = file_name.to_str() else {
            continue;
        };
        if file_name.starts_with('.') {
            continue;
        }
        let dest_path = dst_dir.join(file_name);
        if dest_path.exists() {
            fs::remove_file(&dest_path)?; // to have it updated
        }
        fs::copy(entry.path(), dest_path)?;
    }
    Ok(())
}