BlueGit

timfa bluegit

Files

bluegit / internal / server / project.go

project.go

feat: nieuw-formulier, groepsoverzicht, logo's en talen
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed d1203d3b History
project.go 6.3 KiB Download Raw
1package server
2
3import (
4 "fmt"
5 "html/template"
6 "net/http"
7 "path"
8 "sort"
9 "strings"
10
11 "gitlab.com/Timfa/bluegit/internal/access"
12 "gitlab.com/Timfa/bluegit/internal/gitrepo"
13 "gitlab.com/Timfa/bluegit/internal/highlight"
14 "gitlab.com/Timfa/bluegit/internal/i18n"
15 "gitlab.com/Timfa/bluegit/internal/markdown"
16 "gitlab.com/Timfa/bluegit/internal/store"
17)
18
19func (s *Server) fillOverview(r *http.Request, v *View, repo store.Repo) {
20 v.Page = "overview"
21 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
22 s.branchList(r, v, dir)
23 lang := i18n.Parse(v.Lang)
24 if c, err := gitrepo.LastCommit(r.Context(), s.Git, dir, v.Rev, ""); err == nil && c.SHA != "" {
25 row := commitRow(c, lang)
26 v.Head = &row
27 }
28 entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, "")
29 touch, _ := gitrepo.Touch(r.Context(), s.Git, dir, v.Rev)
30 if err == nil {
31 v.Files = fileRows(entries, "", touch, lang)
32 }
33 readme, license := findDocs(entries)
34 v.LicensePath = license
35 if readme != "" {
36 text, binary, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, readme, 200_000)
37 if err == nil && !binary {
38 v.ReadmeName = readme
39 base := "/" + repo.FullPath() + "/-/blob/"
40 v.Readme = template.HTML(markdown.Render(text, base, v.Rev))
41 }
42 }
43 commits, branches, tags, _ := gitrepo.Stats(r.Context(), s.Git, dir, v.Rev)
44 v.NCommits, v.NBranches, v.NTags = commits, branches, tags
45 if rels, err := s.Store.ListReleases(r.Context(), repo.ID); err == nil {
46 v.NReleases = len(rels)
47 }
48 v.Created = i18n.FormatDate(lang, repo.CreatedAt)
49}
50
51func (s *Server) fillFiles(r *http.Request, v *View, repo store.Repo, rel string, isFile bool) {
52 v.Page = "files"
53 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
54 lang := i18n.Parse(v.Lang)
55 s.branchList(r, v, dir)
56 all, _ := gitrepo.TreeAll(r.Context(), s.Git, dir, v.Rev)
57 v.Tree = treeRows(all, rel)
58 if !isFile {
59 v.TreePath = rel
60 entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel)
61 touch, _ := gitrepo.Touch(r.Context(), s.Git, dir, v.Rev)
62 if err == nil {
63 v.Files = fileRows(entries, rel, touch, lang)
64 }
65 return
66 }
67 v.BlobPath = rel
68 v.FileName = path.Base(rel)
69 text, binary, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 200_000)
70 if err != nil {
71 return
72 }
73 v.Binary = binary
74 if !binary {
75 for i, line := range highlight.Lines(rel, text) {
76 v.Lines = append(v.Lines, CodeLine{N: i + 1, HTML: template.HTML(line)})
77 }
78 }
79 if n, err := gitrepo.BlobSize(r.Context(), s.Git, dir, v.Rev, rel); err == nil {
80 v.BlobSize = formatSize(n)
81 }
82 if c, err := gitrepo.LastCommit(r.Context(), s.Git, dir, v.Rev, rel); err == nil && c.SHA != "" {
83 row := commitRow(c, lang)
84 v.Head = &row
85 }
86}
87
88func (s *Server) branchList(r *http.Request, v *View, dir string) {
89 patterns, _ := s.Store.ProtectedPatterns(r.Context(), v.Repo.ID)
90 v.RevProtected = access.BranchProtected(patterns, v.Rev)
91 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
92 seen := false
93 for _, name := range names {
94 if name == v.Rev {
95 seen = true
96 }
97 v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
98 }
99 if v.Rev != "" && !seen {
100 v.Branches = append([]BranchRow{{Name: v.Rev, Protected: v.RevProtected}}, v.Branches...)
101 }
102}
103
104func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
105 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
106 if !ok {
107 return
108 }
109 v := s.repoView(w, r, repo, role, "title.tags")
110 v.Wide = true
111 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
112 v.TagNames, _ = gitrepo.Tags(r.Context(), s.Git, dir)
113 s.render(w, "tags", v)
114}
115
116func commitRow(c gitrepo.Commit, lang i18n.Lang) CommitRow {
117 return CommitRow{
118 SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date,
119 Subject: c.Subject, Body: c.Body, When: i18n.Ago(lang, c.Unix),
120 }
121}
122
123func fileRows(entries []gitrepo.Entry, base string, touch map[string]gitrepo.Commit, lang i18n.Lang) []FileRow {
124 var out []FileRow
125 for _, e := range entries {
126 p := e.Name
127 if base != "" {
128 p = base + "/" + e.Name
129 }
130 row := FileRow{Name: e.Name, Path: p, Dir: e.Type == "tree", Icon: fileIcon(e.Name, e.Type)}
131 if c, ok := touch[p]; ok {
132 row.Subject = c.Subject
133 row.When = i18n.Ago(lang, c.Unix)
134 row.SHA = c.SHA
135 }
136 out = append(out, row)
137 }
138 sort.Slice(out, func(i, j int) bool {
139 if out[i].Dir != out[j].Dir {
140 return out[i].Dir
141 }
142 return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
143 })
144 return out
145}
146
147func treeRows(entries []gitrepo.Entry, current string) []FileRow {
148 var out []FileRow
149 for _, e := range entries {
150 base := e.Name
151 if i := strings.LastIndex(e.Name, "/"); i >= 0 {
152 base = e.Name[i+1:]
153 }
154 depth := strings.Count(e.Name, "/")
155 if depth > 8 {
156 depth = 8
157 }
158 active := e.Name == current
159 if e.Type == "tree" && (current == e.Name || strings.HasPrefix(current, e.Name+"/")) {
160 active = true
161 }
162 out = append(out, FileRow{
163 Name: base, Path: e.Name, Dir: e.Type == "tree", Icon: fileIcon(base, e.Type),
164 Depth: depth, Active: active,
165 })
166 }
167 return out
168}
169
170func findDocs(entries []gitrepo.Entry) (readme, license string) {
171 readmeRank := 9
172 for _, e := range entries {
173 if e.Type != "blob" {
174 continue
175 }
176 low := strings.ToLower(e.Name)
177 rank := 9
178 switch low {
179 case "readme.md":
180 rank = 0
181 case "readme.markdown":
182 rank = 1
183 case "readme":
184 rank = 2
185 }
186 if rank < readmeRank {
187 readmeRank = rank
188 readme = e.Name
189 }
190 switch low {
191 case "license", "license.md", "license.txt", "licence", "copying":
192 if license == "" || low == "license" {
193 license = e.Name
194 }
195 }
196 }
197 return readme, license
198}
199
200func fileIcon(name, typ string) string {
201 if typ == "tree" {
202 return "dir"
203 }
204 switch strings.ToLower(path.Ext(name)) {
205 case ".md", ".markdown":
206 return "md"
207 case ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp":
208 return "img"
209 case ".go", ".js", ".ts", ".py", ".rs", ".c", ".h", ".rb", ".sh":
210 return "code"
211 case ".yml", ".yaml", ".toml", ".json", ".lock":
212 return "cfg"
213 }
214 base := strings.ToLower(name)
215 if base == "license" || base == "licence" || base == "copying" || strings.HasPrefix(base, "license.") {
216 return "lic"
217 }
218 if strings.HasPrefix(base, "readme") {
219 return "md"
220 }
221 return "file"
222}
223
224func formatSize(n int64) string {
225 if n < 1024 {
226 return fmt.Sprintf("%d B", n)
227 }
228 if n < 1024*1024 {
229 return fmt.Sprintf("%.1f KiB", float64(n)/1024)
230 }
231 return fmt.Sprintf("%.1f MiB", float64(n)/(1024*1024))
232}