weaveconfig 0.3.0

A unified configuration tool for monorepos
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::{collections::HashMap, path::PathBuf};

use anyhow::Context;

use crate::{file_graph::Directory, schemas::GenerateSchema};
use std::collections::HashSet;

#[derive(Debug, Clone, PartialEq)]
pub struct Space {
    pub name: String,
    pub path: PathBuf,
    pub dependencies: Vec<String>,
    pub mapping: Option<HashMap<String, Vec<String>>>,
    pub environments: HashSet<String>,
    pub variables: Option<serde_json::Map<String, serde_json::Value>>,
    pub files_to_copy: CopyTree,
    pub parent_space: Option<String>,
    pub generate: GenerateSpace,
}

#[derive(Debug, Clone, PartialEq)]
pub struct CopyTree {
    pub to_copy: Vec<ToCopy>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum ToCopy {
    File(PathBuf),
    Directory { path: PathBuf, subtree: CopyTree },
}

impl ToCopy {
    pub fn last_segment(&self) -> Result<&str, anyhow::Error> {
        let path = match self {
            ToCopy::File(path) => path,
            ToCopy::Directory { path, .. } => path,
        };
        let file_name = path.file_name().context("File has no name")?;
        let file_name = file_name
            .to_str()
            .context("File name is not valid unicode")?;
        Ok(file_name)
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct GenerateSpace {
    pub generate: bool,
    pub typescript: bool,
}

pub type SpaceGraph = HashMap<String, Space>;

pub fn create_space_graph(root_directory: Directory) -> SpaceGraph {
    let mut space_graph = HashMap::new();

    add_to_spaces_graph(root_directory, &mut space_graph, None);

    space_graph
}

fn add_to_spaces_graph(
    mut dir: Directory,
    space_graph: &mut SpaceGraph,
    closest_parent_space: Option<String>,
) {
    let space_name = dir
        .space
        .as_ref()
        .map(|s| s.schema.name.to_string())
        .or_else(|| closest_parent_space.clone());
    if let Some(space) = dir.space.take() {
        let space = Space {
            name: space.schema.name,
            path: dir.path.clone(),
            dependencies: space.schema.dependencies.unwrap_or_default(),
            mapping: space.schema.mapping.map(|m| {
                let mut map = HashMap::new();
                for mapping in m {
                    map.entry(mapping.from).or_insert(vec![]).push(mapping.to);
                }
                map
            }),
            environments: space.schema.environments.unwrap_or_default(),
            variables: space.variables,
            files_to_copy: resolve_files_to_copy(&dir),
            parent_space: closest_parent_space,
            generate: {
                match space.schema.generate {
                    Some(GenerateSchema::Generate(generate)) => GenerateSpace {
                        generate: true,
                        typescript: generate.typescript,
                    },
                    Some(GenerateSchema::ShouldGenerate(generate)) => GenerateSpace {
                        generate,
                        typescript: true,
                    },
                    None => GenerateSpace {
                        generate: true,
                        typescript: true,
                    },
                }
            },
        };
        space_graph.insert(space.name.clone(), space);
    }

    for entry in dir.directories {
        add_to_spaces_graph(entry, space_graph, space_name.clone());
    }
}

fn resolve_files_to_copy(dir: &Directory) -> CopyTree {
    let mut files = vec![];
    for file in &dir.rest_to_copy {
        files.push(ToCopy::File(file.clone()));
    }

    for entry in &dir.directories {
        if entry.space.is_none() {
            files.push(ToCopy::Directory {
                path: entry.path.clone(),
                subtree: resolve_files_to_copy(entry),
            });
        }
    }

    CopyTree { to_copy: files }
}