Repository navigation
Expand file tree
/
Copy pathNavigationGraphBuilder.cs
More file actions
231 lines (206 loc) · 8.95 KB
/
Copy pathNavigationGraphBuilder.cs
File metadata and controls
231 lines (206 loc) · 8.95 KB
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
namespace ShellDocs.Core;
public static class NavigationGraphBuilder
{
public static NavigationGraph Build(string contentRoot)
{
var abs = System.IO.Path.GetFullPath(contentRoot);
if (!Directory.Exists(abs))
{
throw new DirectoryNotFoundException($"Content root not found: {contentRoot}");
}
var rootNode = new NavigationNode
{
Title = "",
Url = "/",
Kind = NodeKind.Section,
Path = abs
};
var hidden = new List<NavigationNode>();
var children = BuildFolder(abs, abs, urlPrefix: "", hidden);
LinkChildren(rootNode, children);
return new NavigationGraph(rootNode, hidden);
}
private static List<NavigationNode> BuildFolder(string folder, string root, string urlPrefix, List<NavigationNode> hidden)
{
var meta = ReadMeta(folder);
var mdFiles = Directory.GetFiles(folder, "*.md", SearchOption.TopDirectoryOnly);
var subfolders = Directory.GetDirectories(folder);
var slugToNode = mdFiles.ToDictionary(
path => SlugFrom(path),
path => BuildPage(path, root, urlPrefix),
StringComparer.OrdinalIgnoreCase);
var folderNameToChildren = subfolders.ToDictionary(
path => System.IO.Path.GetFileName(path),
path => (folderPath: path, children: BuildFolder(path, root, CombineUrl(urlPrefix, System.IO.Path.GetFileName(path)), hidden)),
StringComparer.OrdinalIgnoreCase);
// No meta.json: alphabetical ordering, subfolders inline as sections.
if (meta is null)
{
var ordered = new List<NavigationNode>();
foreach (var (name, tuple) in folderNameToChildren.OrderBy(kv => kv.Key, StringComparer.OrdinalIgnoreCase))
{
var section = new NavigationNode
{
Title = FolderTitle(tuple.folderPath),
Kind = NodeKind.Section,
Path = tuple.folderPath
};
LinkChildren(section, tuple.children);
ordered.Add(section);
}
ordered.AddRange(slugToNode.Values.OrderBy(n => n.Order).ThenBy(n => n.Title, StringComparer.OrdinalIgnoreCase));
return ordered;
}
var result = new List<NavigationNode>();
var consumedSlugs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var consumedFolders = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
// meta.hidden entries route but stay out of the tree: pre-consume them so
// neither loop below renders them, and hand the nodes to the graph's index.
foreach (var slug in meta.Hidden)
{
consumedSlugs.Add(slug);
consumedFolders.Add(slug);
if (slugToNode.TryGetValue(slug, out var hiddenPage))
hidden.Add(hiddenPage);
if (folderNameToChildren.TryGetValue(slug, out var hiddenFolder))
{
// Wrapped so the graph's index walk reaches every page in the folder.
var section = new NavigationNode
{
Title = FolderTitle(hiddenFolder.folderPath),
Kind = NodeKind.Section,
Path = hiddenFolder.folderPath
};
LinkChildren(section, hiddenFolder.children);
hidden.Add(section);
}
}
foreach (var entry in meta.Pages)
{
var node = ResolveEntry(entry, slugToNode, folderNameToChildren, root, urlPrefix, consumedSlugs, consumedFolders);
if (node is not null) result.Add(node);
}
/* meta.json orders what it lists; the file tree decides presence. Unlisted
files and folders are appended alphabetically so new pages show up
without touching meta.json. */
foreach (var (name, tuple) in folderNameToChildren.OrderBy(kv => kv.Key, StringComparer.OrdinalIgnoreCase))
{
if (consumedFolders.Contains(name)) continue;
var section = new NavigationNode
{
Title = FolderTitle(tuple.folderPath),
Kind = NodeKind.Section,
Path = tuple.folderPath
};
LinkChildren(section, tuple.children);
result.Add(section);
}
foreach (var page in slugToNode
.Where(kv => !consumedSlugs.Contains(kv.Key))
.Select(kv => kv.Value)
.OrderBy(n => n.Order)
.ThenBy(n => n.Title, StringComparer.OrdinalIgnoreCase))
{
result.Add(page);
}
return result;
}
private static NavigationNode? ResolveEntry(
MetaJsonEntry entry,
Dictionary<string, NavigationNode> slugToNode,
Dictionary<string, (string folderPath, List<NavigationNode> children)> folderNameToChildren,
string root,
string urlPrefix,
HashSet<string> consumedSlugs,
HashSet<string> consumedFolders)
{
switch (entry)
{
case MetaJsonPageRef pageRef:
// Hidden entries were pre-seeded into these sets; skip so a
// slug listed in both `hidden` and `pages` stays hidden.
if (consumedSlugs.Contains(pageRef.Slug) || consumedFolders.Contains(pageRef.Slug))
return null;
if (slugToNode.TryGetValue(pageRef.Slug, out var page))
{
consumedSlugs.Add(pageRef.Slug);
return page;
}
if (folderNameToChildren.TryGetValue(pageRef.Slug, out var folder))
{
consumedFolders.Add(pageRef.Slug);
var section = new NavigationNode
{
Title = FolderTitle(folder.folderPath),
Kind = NodeKind.Section,
Path = folder.folderPath
};
LinkChildren(section, folder.children);
return section;
}
return null;
case MetaJsonDivider:
return new NavigationNode { Kind = NodeKind.Divider };
case MetaJsonSubsection sub:
var subNode = new NavigationNode
{
Title = sub.Title,
Kind = NodeKind.Section
};
var subChildren = new List<NavigationNode>();
foreach (var e in sub.Pages)
{
var child = ResolveEntry(e, slugToNode, folderNameToChildren, root, urlPrefix, consumedSlugs, consumedFolders);
if (child is not null) subChildren.Add(child);
}
LinkChildren(subNode, subChildren);
return subNode;
default:
return null;
}
}
private static NavigationNode BuildPage(string path, string root, string urlPrefix)
{
var raw = File.ReadAllText(path);
var parsed = FrontmatterParser.Parse(raw);
var slug = SlugFrom(path);
var url = slug == "index" ? EnsureLeadingSlash(urlPrefix) : CombineUrl(urlPrefix, slug);
if (url == "") url = "/";
return new NavigationNode
{
Url = url,
Title = parsed.Frontmatter.GetValue<string>("title") ?? TitleFromSlug(slug),
Description = parsed.Frontmatter.GetValue<string>("description"),
Category = parsed.Frontmatter.GetValue<string>("category"),
Order = parsed.Frontmatter.GetValue<int>("order"),
Path = path,
Kind = NodeKind.Page
};
}
private static MetaJson? ReadMeta(string folder)
{
var metaPath = System.IO.Path.Combine(folder, "meta.json");
return File.Exists(metaPath) ? MetaJson.Parse(File.ReadAllText(metaPath)) : null;
}
private static void LinkChildren(NavigationNode parent, IReadOnlyList<NavigationNode> children)
{
foreach (var child in children) child.Parent = parent;
parent.Children = children;
}
private static string SlugFrom(string mdPath)
=> System.IO.Path.GetFileNameWithoutExtension(mdPath);
private static string TitleFromSlug(string slug)
=> string.Join(' ', slug.Split('-').Select(w => w.Length == 0 ? w : char.ToUpper(w[0]) + w[1..]));
// The folder's own meta.json title, else one made from its name.
private static string FolderTitle(string folderPath)
=> ReadMeta(folderPath)?.Title is { Length: > 0 } title
? title
: TitleFromSlug(System.IO.Path.GetFileName(folderPath));
private static string EnsureLeadingSlash(string s) => s.StartsWith('/') ? s : "/" + s;
private static string CombineUrl(string prefix, string segment)
{
var p = prefix.TrimEnd('/');
var s = segment.Trim('/');
return string.IsNullOrEmpty(p) ? "/" + s : p + "/" + s;
}
}