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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
from collections.abc import Mapping
import os
import os.path
from pathlib import Path
from string import Template
from ._iter import CruIterator
from ._error import CruException
class CruTemplateError(CruException):
pass
class CruTemplate:
def __init__(self, prefix: str, text: str):
self._prefix = prefix
self._template = Template(text)
self._variables = (
CruIterator(self._template.get_identifiers())
.filter(lambda i: i.startswith(self._prefix))
.to_set()
)
self._all_variables = set(self._template.get_identifiers())
@property
def prefix(self) -> str:
return self._prefix
@property
def raw_text(self) -> str:
return self._template.template
@property
def py_template(self) -> Template:
return self._template
@property
def variables(self) -> set[str]:
return self._variables
@property
def all_variables(self) -> set[str]:
return self._all_variables
@property
def has_variables(self) -> bool:
"""
If the template does not has any variables that starts with the given prefix,
it returns False. This usually indicates that the template is not a real
template and should be copied as is. Otherwise, it returns True.
This can be used as a guard to prevent invalid templates created accidentally
without notice.
"""
return len(self.variables) > 0
def generate(self, mapping: Mapping[str, str], allow_extra: bool = True) -> str:
values = dict(mapping)
if not self.variables <= set(values.keys()):
raise CruTemplateError("Missing variables.")
if not allow_extra and not set(values.keys()) <= self.variables:
raise CruTemplateError("Extra variables.")
return self._template.safe_substitute(values)
class TemplateTree:
def __init__(
self,
prefix: str,
source: str,
template_file_suffix: str | None = ".template",
):
"""
If template_file_suffix is not None, the files will be checked according to the
suffix of the file name. If the suffix matches, the file will be regarded as a
template file. Otherwise, it will be regarded as a non-template file.
Content of template file must contain variables that need to be replaced, while
content of non-template file may not contain any variables.
If either case is false, it generally means whether the file is a template is
wrongly handled.
"""
self._prefix = prefix
self._files: list[tuple[Path, CruTemplate]] = []
self._source = source
self._template_file_suffix = template_file_suffix
self._load()
@property
def prefix(self) -> str:
return self._prefix
@property
def templates(self) -> list[tuple[Path, CruTemplate]]:
return self._files
@property
def source(self) -> str:
return self._source
@property
def template_file_suffix(self) -> str | None:
return self._template_file_suffix
@staticmethod
def _scan_files(root_path: str) -> list[Path]:
result: list[Path] = []
for root, _dirs, files in os.walk(root_path):
for file in files:
path = Path(root, file)
path = path.relative_to(root_path)
result.append(Path(path))
return result
def _load(self) -> None:
files = self._scan_files(self.source)
for file_path in files:
template_file = Path(self.source) / file_path
with open(template_file, "r") as f:
content = f.read()
template = CruTemplate(self.prefix, content)
if self.template_file_suffix is not None:
should_be_template = file_path.name.endswith(self.template_file_suffix)
if should_be_template and not template.has_variables:
raise CruTemplateError(
f"Template file {file_path} has no variables."
)
elif not should_be_template and template.has_variables:
raise CruTemplateError(f"Non-template {file_path} has variables.")
self._files.append((file_path, template))
@property
def variables(self) -> set[str]:
s = set()
for _, template in self.templates:
s.update(template.variables)
return s
def generate_to(
self, destination: str, variables: Mapping[str, str], dry_run: bool
) -> None:
for file, template in self.templates:
des = Path(destination) / file
if self.template_file_suffix is not None and des.name.endswith(
self.template_file_suffix
):
des = des.parent / (des.name[: -len(self.template_file_suffix)])
text = template.generate(variables)
if not dry_run:
des.parent.mkdir(parents=True, exist_ok=True)
with open(des, "w") as f:
f.write(text)
|
