501 lines
11 kB
1
package pages
2
3
import (
4
"bytes"
5
"embed"
6
"fmt"
7
"html"
8
"html/template"
9
"io"
10
"io/fs"
11
"log"
12
"net/http"
13
"path"
14
"path/filepath"
15
"strings"
16
17
"github.com/alecthomas/chroma/v2"
18
chromahtml "github.com/alecthomas/chroma/v2/formatters/html"
19
"github.com/alecthomas/chroma/v2/lexers"
20
"github.com/alecthomas/chroma/v2/styles"
21
"github.com/dustin/go-humanize"
22
"github.com/sotangled/tangled/appview/auth"
23
"github.com/sotangled/tangled/appview/db"
24
"github.com/sotangled/tangled/types"
25
)
26
27
//go:embed templates/* static/*
28
var files embed.FS
29
30
type Pages struct {
31
t map[string]*template.Template
32
}
33
34
func funcMap() template.FuncMap {
35
return template.FuncMap{
36
"split": func(s string) []string {
37
return strings.Split(s, "\n")
38
},
39
"splitOn": func(s, sep string) []string {
40
return strings.Split(s, sep)
41
},
42
"add": func(a, b int) int {
43
return a + b
44
},
45
"sub": func(a, b int) int {
46
return a - b
47
},
48
"cond": func(cond interface{}, a, b string) string {
49
if cond == nil {
50
return b
51
}
52
53
if boolean, ok := cond.(bool); boolean && ok {
54
return a
55
}
56
57
return b
58
},
59
"didOrHandle": func(did, handle string) string {
60
if handle != "" {
61
return fmt.Sprintf("@%s", handle)
62
} else {
63
return did
64
}
65
},
66
"assoc": func(values ...string) ([][]string, error) {
67
if len(values)%2 != 0 {
68
return nil, fmt.Errorf("invalid assoc call, must have an even number of arguments")
69
}
70
pairs := make([][]string, 0)
71
for i := 0; i < len(values); i += 2 {
72
pairs = append(pairs, []string{values[i], values[i+1]})
73
}
74
return pairs, nil
75
},
76
"append": func(s []string, values ...string) []string {
77
s = append(s, values...)
78
return s
79
},
80
"timeFmt": humanize.Time,
81
"byteFmt": humanize.Bytes,
82
"length": func(v []string) int {
83
return len(v)
84
},
85
"splitN": func(s, sep string, n int) []string {
86
return strings.SplitN(s, sep, n)
87
},
88
"escapeHtml": func(s string) template.HTML {
89
if s == "" {
90
return template.HTML("<br>")
91
}
92
return template.HTML(s)
93
},
94
"unescapeHtml": func(s string) string {
95
return html.UnescapeString(s)
96
},
97
"nl2br": func(text string) template.HTML {
98
return template.HTML(strings.Replace(template.HTMLEscapeString(text), "\n", "<br>", -1))
99
},
100
"unwrapText": func(text string) string {
101
paragraphs := strings.Split(text, "\n\n")
102
103
for i, p := range paragraphs {
104
lines := strings.Split(p, "\n")
105
paragraphs[i] = strings.Join(lines, " ")
106
}
107
108
return strings.Join(paragraphs, "\n\n")
109
},
110
"sequence": func(n int) []struct{} {
111
return make([]struct{}, n)
112
},
113
}
114
}
115
116
func NewPages() *Pages {
117
templates := make(map[string]*template.Template)
118
119
// Walk through embedded templates directory and parse all .html files
120
err := fs.WalkDir(files, "templates", func(path string, d fs.DirEntry, err error) error {
121
if err != nil {
122
return err
123
}
124
125
if !d.IsDir() && strings.HasSuffix(path, ".html") {
126
name := strings.TrimPrefix(path, "templates/")
127
name = strings.TrimSuffix(name, ".html")
128
129
if !strings.HasPrefix(path, "templates/layouts/") {
130
// Add the page template on top of the base
131
tmpl, err := template.New(name).
132
Funcs(funcMap()).
133
ParseFS(files, "templates/layouts/*.html", path)
134
if err != nil {
135
return fmt.Errorf("setting up template: %w", err)
136
}
137
138
templates[name] = tmpl
139
log.Printf("loaded template: %s", name)
140
}
141
142
return nil
143
}
144
return nil
145
})
146
if err != nil {
147
log.Fatalf("walking template dir: %v", err)
148
}
149
150
log.Printf("total templates loaded: %d", len(templates))
151
152
return &Pages{
153
t: templates,
154
}
155
}
156
157
type LoginParams struct {
158
}
159
160
func (p *Pages) execute(name string, w io.Writer, params any) error {
161
return p.t[name].ExecuteTemplate(w, "layouts/base", params)
162
}
163
164
func (p *Pages) executePlain(name string, w io.Writer, params any) error {
165
return p.t[name].Execute(w, params)
166
}
167
168
func (p *Pages) executeRepo(name string, w io.Writer, params any) error {
169
return p.t[name].ExecuteTemplate(w, "layouts/repobase", params)
170
}
171
172
func (p *Pages) Login(w io.Writer, params LoginParams) error {
173
return p.executePlain("user/login", w, params)
174
}
175
176
type TimelineParams struct {
177
LoggedInUser *auth.User
178
Timeline []db.TimelineEvent
179
DidHandleMap map[string]string
180
}
181
182
func (p *Pages) Timeline(w io.Writer, params TimelineParams) error {
183
return p.execute("timeline", w, params)
184
}
185
186
type SettingsParams struct {
187
LoggedInUser *auth.User
188
PubKeys []db.PublicKey
189
}
190
191
func (p *Pages) Settings(w io.Writer, params SettingsParams) error {
192
return p.execute("settings/keys", w, params)
193
}
194
195
type KnotsParams struct {
196
LoggedInUser *auth.User
197
Registrations []db.Registration
198
}
199
200
func (p *Pages) Knots(w io.Writer, params KnotsParams) error {
201
return p.execute("knots", w, params)
202
}
203
204
type KnotParams struct {
205
LoggedInUser *auth.User
206
Registration *db.Registration
207
Members []string
208
IsOwner bool
209
}
210
211
func (p *Pages) Knot(w io.Writer, params KnotParams) error {
212
return p.execute("knot", w, params)
213
}
214
215
type NewRepoParams struct {
216
LoggedInUser *auth.User
217
Knots []string
218
}
219
220
func (p *Pages) NewRepo(w io.Writer, params NewRepoParams) error {
221
return p.execute("repo/new", w, params)
222
}
223
224
type ProfilePageParams struct {
225
LoggedInUser *auth.User
226
UserDid string
227
UserHandle string
228
Repos []db.Repo
229
CollaboratingRepos []db.Repo
230
ProfileStats ProfileStats
231
FollowStatus db.FollowStatus
232
}
233
234
type ProfileStats struct {
235
Followers int
236
Following int
237
}
238
239
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {
240
return p.execute("user/profile", w, params)
241
}
242
243
type RepoInfo struct {
244
Name string
245
OwnerDid string
246
OwnerHandle string
247
Description string
248
SettingsAllowed bool
249
}
250
251
func (r RepoInfo) OwnerWithAt() string {
252
if r.OwnerHandle != "" {
253
return fmt.Sprintf("@%s", r.OwnerHandle)
254
} else {
255
return r.OwnerDid
256
}
257
}
258
259
func (r RepoInfo) FullName() string {
260
return path.Join(r.OwnerWithAt(), r.Name)
261
}
262
263
func (r RepoInfo) GetTabs() [][]string {
264
tabs := [][]string{
265
{"overview", "/"},
266
{"issues", "/issues"},
267
{"pulls", "/pulls"},
268
}
269
270
if r.SettingsAllowed {
271
tabs = append(tabs, []string{"settings", "/settings"})
272
}
273
274
return tabs
275
}
276
277
type RepoIndexParams struct {
278
LoggedInUser *auth.User
279
RepoInfo RepoInfo
280
Active string
281
types.RepoIndexResponse
282
}
283
284
func (p *Pages) RepoIndexPage(w io.Writer, params RepoIndexParams) error {
285
params.Active = "overview"
286
if params.IsEmpty {
287
return p.executeRepo("repo/empty", w, params)
288
}
289
return p.executeRepo("repo/index", w, params)
290
}
291
292
type RepoLogParams struct {
293
LoggedInUser *auth.User
294
RepoInfo RepoInfo
295
types.RepoLogResponse
296
Active string
297
}
298
299
func (p *Pages) RepoLog(w io.Writer, params RepoLogParams) error {
300
params.Active = "overview"
301
return p.execute("repo/log", w, params)
302
}
303
304
type RepoCommitParams struct {
305
LoggedInUser *auth.User
306
RepoInfo RepoInfo
307
Active string
308
types.RepoCommitResponse
309
}
310
311
func (p *Pages) RepoCommit(w io.Writer, params RepoCommitParams) error {
312
params.Active = "overview"
313
return p.executeRepo("repo/commit", w, params)
314
}
315
316
type RepoTreeParams struct {
317
LoggedInUser *auth.User
318
RepoInfo RepoInfo
319
Active string
320
BreadCrumbs [][]string
321
BaseTreeLink string
322
BaseBlobLink string
323
types.RepoTreeResponse
324
}
325
326
type RepoTreeStats struct {
327
NumFolders uint64
328
NumFiles uint64
329
}
330
331
func (r RepoTreeParams) TreeStats() RepoTreeStats {
332
numFolders, numFiles := 0, 0
333
for _, f := range r.Files {
334
if !f.IsFile {
335
numFolders += 1
336
} else if f.IsFile {
337
numFiles += 1
338
}
339
}
340
341
return RepoTreeStats{
342
NumFolders: uint64(numFolders),
343
NumFiles: uint64(numFiles),
344
}
345
}
346
347
func (p *Pages) RepoTree(w io.Writer, params RepoTreeParams) error {
348
params.Active = "overview"
349
return p.execute("repo/tree", w, params)
350
}
351
352
type RepoBranchesParams struct {
353
LoggedInUser *auth.User
354
RepoInfo RepoInfo
355
types.RepoBranchesResponse
356
}
357
358
func (p *Pages) RepoBranches(w io.Writer, params RepoBranchesParams) error {
359
return p.executeRepo("repo/branches", w, params)
360
}
361
362
type RepoTagsParams struct {
363
LoggedInUser *auth.User
364
RepoInfo RepoInfo
365
types.RepoTagsResponse
366
}
367
368
func (p *Pages) RepoTags(w io.Writer, params RepoTagsParams) error {
369
return p.executeRepo("repo/tags", w, params)
370
}
371
372
type RepoBlobParams struct {
373
LoggedInUser *auth.User
374
RepoInfo RepoInfo
375
Active string
376
BreadCrumbs [][]string
377
types.RepoBlobResponse
378
}
379
380
func (p *Pages) RepoBlob(w io.Writer, params RepoBlobParams) error {
381
style := styles.Get("bw")
382
b := style.Builder()
383
b.Add(chroma.LiteralString, "noitalic")
384
style, _ = b.Build()
385
386
if params.Lines < 5000 {
387
c := params.Contents
388
formatter := chromahtml.New(
389
chromahtml.InlineCode(true),
390
chromahtml.WithLineNumbers(true),
391
chromahtml.WithLinkableLineNumbers(true, "L"),
392
chromahtml.Standalone(false),
393
)
394
395
lexer := lexers.Get(filepath.Base(params.Path))
396
if lexer == nil {
397
lexer = lexers.Fallback
398
}
399
400
iterator, err := lexer.Tokenise(nil, c)
401
if err != nil {
402
return fmt.Errorf("chroma tokenize: %w", err)
403
}
404
405
var code bytes.Buffer
406
err = formatter.Format(&code, style, iterator)
407
if err != nil {
408
return fmt.Errorf("chroma format: %w", err)
409
}
410
411
params.Contents = code.String()
412
}
413
414
params.Active = "overview"
415
return p.executeRepo("repo/blob", w, params)
416
}
417
418
type Collaborator struct {
419
Did string
420
Handle string
421
Role string
422
}
423
424
type RepoSettingsParams struct {
425
LoggedInUser *auth.User
426
RepoInfo RepoInfo
427
Collaborators []Collaborator
428
Active string
429
IsCollaboratorInviteAllowed bool
430
}
431
432
func (p *Pages) RepoSettings(w io.Writer, params RepoSettingsParams) error {
433
params.Active = "settings"
434
return p.executeRepo("repo/settings", w, params)
435
}
436
437
type RepoIssuesParams struct {
438
LoggedInUser *auth.User
439
RepoInfo RepoInfo
440
Active string
441
Issues []db.Issue
442
DidHandleMap map[string]string
443
}
444
445
func (p *Pages) RepoIssues(w io.Writer, params RepoIssuesParams) error {
446
params.Active = "issues"
447
return p.executeRepo("repo/issues/issues", w, params)
448
}
449
450
type RepoSingleIssueParams struct {
451
LoggedInUser *auth.User
452
RepoInfo RepoInfo
453
Active string
454
Issue db.Issue
455
Comments []db.Comment
456
IssueOwnerHandle string
457
DidHandleMap map[string]string
458
459
State string
460
}
461
462
func (p *Pages) RepoSingleIssue(w io.Writer, params RepoSingleIssueParams) error {
463
params.Active = "issues"
464
if params.Issue.Open {
465
params.State = "open"
466
} else {
467
params.State = "closed"
468
}
469
return p.execute("repo/issues/issue", w, params)
470
}
471
472
type RepoNewIssueParams struct {
473
LoggedInUser *auth.User
474
RepoInfo RepoInfo
475
Active string
476
}
477
478
func (p *Pages) RepoNewIssue(w io.Writer, params RepoNewIssueParams) error {
479
params.Active = "issues"
480
return p.executeRepo("repo/issues/new", w, params)
481
}
482
483
func (p *Pages) Static() http.Handler {
484
sub, err := fs.Sub(files, "static")
485
if err != nil {
486
log.Fatalf("no static dir found? that's crazy: %v", err)
487
}
488
return http.StripPrefix("/static/", http.FileServer(http.FS(sub)))
489
}
490
491
func (p *Pages) Error500(w io.Writer) error {
492
return p.execute("errors/500", w, nil)
493
}
494
495
func (p *Pages) Error404(w io.Writer) error {
496
return p.execute("errors/404", w, nil)
497
}
498
499
func (p *Pages) Error503(w io.Writer) error {
500
return p.execute("errors/503", w, nil)
501
}
502