BlueGit

timfa bluegit

Files

bluegit / internal / server / project.go

project.go

feat: projectpagina met overzicht en bestanden
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed ea0d24ce History
project.go 7.4 KiB Download Raw
1package server
2
3import (
4 "fmt"
5 "html/template"
6 "net/http"
7 "path"
8 "sort"
9 "strings"
10 "time"
11
12 "gitlab.com/Timfa/bluegit/internal/access"
13 "gitlab.com/Timfa/bluegit/internal/gitrepo"
14 "gitlab.com/Timfa/bluegit/internal/highlight"
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 if c, err := gitrepo.LastCommit(r.Context(), s.Git, dir, v.Rev, ""); err == nil && c.SHA != "" {
24 row := commitRow(c)
25 v.Head = &row
26 }
27 entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, "")
28 touch, _ := gitrepo.Touch(r.Context(), s.Git, dir, v.Rev)
29 if err == nil {
30 v.Files = fileRows(entries, "", touch)
31 }
32 readme, license := findDocs(entries)
33 v.LicensePath = license
34 if readme != "" {
35 text, binary, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, readme, 200_000)
36 if err == nil && !binary {
37 v.ReadmeName = readme
38 base := "/" + repo.FullPath() + "/-/blob/"
39 v.Readme = template.HTML(markdown.Render(text, base, v.Rev))
40 }
41 }
42 commits, branches, tags, _ := gitrepo.Stats(r.Context(), s.Git, dir, v.Rev)
43 v.NCommits, v.NBranches, v.NTags = commits, branches, tags
44 if rels, err := s.Store.ListReleases(r.Context(), repo.ID); err == nil {
45 v.NReleases = len(rels)
46 }
47 v.Created = dutchDate(repo.CreatedAt)
48}
49
50func (s *Server) fillFiles(r *http.Request, v *View, repo store.Repo, rel string, isFile bool) {
51 v.Page = "files"
52 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
53 s.branchList(r, v, dir)
54 all, _ := gitrepo.TreeAll(r.Context(), s.Git, dir, v.Rev)
55 v.Tree = treeRows(all, rel)
56 if !isFile {
57 v.TreePath = rel
58 entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel)
59 touch, _ := gitrepo.Touch(r.Context(), s.Git, dir, v.Rev)
60 if err == nil {
61 v.Files = fileRows(entries, rel, touch)
62 }
63 return
64 }
65 v.BlobPath = rel
66 v.FileName = path.Base(rel)
67 text, binary, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 200_000)
68 if err != nil {
69 return
70 }
71 v.Binary = binary
72 if !binary {
73 for i, line := range highlight.Lines(rel, text) {
74 v.Lines = append(v.Lines, CodeLine{N: i + 1, HTML: template.HTML(line)})
75 }
76 }
77 if n, err := gitrepo.BlobSize(r.Context(), s.Git, dir, v.Rev, rel); err == nil {
78 v.BlobSize = formatSize(n)
79 }
80 if c, err := gitrepo.LastCommit(r.Context(), s.Git, dir, v.Rev, rel); err == nil && c.SHA != "" {
81 row := commitRow(c)
82 v.Head = &row
83 }
84}
85
86func (s *Server) branchList(r *http.Request, v *View, dir string) {
87 patterns, _ := s.Store.ProtectedPatterns(r.Context(), v.Repo.ID)
88 v.RevProtected = access.BranchProtected(patterns, v.Rev)
89 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
90 seen := false
91 for _, name := range names {
92 if name == v.Rev {
93 seen = true
94 }
95 v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
96 }
97 if v.Rev != "" && !seen {
98 v.Branches = append([]BranchRow{{Name: v.Rev, Protected: v.RevProtected}}, v.Branches...)
99 }
100}
101
102func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
103 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
104 if !ok {
105 return
106 }
107 v := s.repoView(w, r, repo, role, "Tags")
108 v.Wide = true
109 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
110 v.TagNames, _ = gitrepo.Tags(r.Context(), s.Git, dir)
111 s.render(w, "tags", v)
112}
113
114func commitRow(c gitrepo.Commit) CommitRow {
115 return CommitRow{
116 SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date,
117 Subject: c.Subject, Body: c.Body, When: ago(c.Unix),
118 }
119}
120
121func fileRows(entries []gitrepo.Entry, base string, touch map[string]gitrepo.Commit) []FileRow {
122 var out []FileRow
123 for _, e := range entries {
124 p := e.Name
125 if base != "" {
126 p = base + "/" + e.Name
127 }
128 row := FileRow{Name: e.Name, Path: p, Dir: e.Type == "tree", Icon: fileIcon(e.Name, e.Type)}
129 if c, ok := touch[p]; ok {
130 row.Subject = c.Subject
131 row.When = ago(c.Unix)
132 row.SHA = c.SHA
133 }
134 out = append(out, row)
135 }
136 sort.Slice(out, func(i, j int) bool {
137 if out[i].Dir != out[j].Dir {
138 return out[i].Dir
139 }
140 return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
141 })
142 return out
143}
144
145func treeRows(entries []gitrepo.Entry, current string) []FileRow {
146 var out []FileRow
147 for _, e := range entries {
148 base := e.Name
149 if i := strings.LastIndex(e.Name, "/"); i >= 0 {
150 base = e.Name[i+1:]
151 }
152 depth := strings.Count(e.Name, "/")
153 if depth > 8 {
154 depth = 8
155 }
156 active := e.Name == current
157 if e.Type == "tree" && (current == e.Name || strings.HasPrefix(current, e.Name+"/")) {
158 active = true
159 }
160 out = append(out, FileRow{
161 Name: base, Path: e.Name, Dir: e.Type == "tree", Icon: fileIcon(base, e.Type),
162 Depth: depth, Active: active,
163 })
164 }
165 return out
166}
167
168func findDocs(entries []gitrepo.Entry) (readme, license string) {
169 readmeRank := 9
170 for _, e := range entries {
171 if e.Type != "blob" {
172 continue
173 }
174 low := strings.ToLower(e.Name)
175 rank := 9
176 switch low {
177 case "readme.md":
178 rank = 0
179 case "readme.markdown":
180 rank = 1
181 case "readme":
182 rank = 2
183 }
184 if rank < readmeRank {
185 readmeRank = rank
186 readme = e.Name
187 }
188 switch low {
189 case "license", "license.md", "license.txt", "licence", "copying":
190 if license == "" || low == "license" {
191 license = e.Name
192 }
193 }
194 }
195 return readme, license
196}
197
198func fileIcon(name, typ string) string {
199 if typ == "tree" {
200 return "dir"
201 }
202 switch strings.ToLower(path.Ext(name)) {
203 case ".md", ".markdown":
204 return "md"
205 case ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp":
206 return "img"
207 case ".go", ".js", ".ts", ".py", ".rs", ".c", ".h", ".rb", ".sh":
208 return "code"
209 case ".yml", ".yaml", ".toml", ".json", ".lock":
210 return "cfg"
211 }
212 base := strings.ToLower(name)
213 if base == "license" || base == "licence" || base == "copying" || strings.HasPrefix(base, "license.") {
214 return "lic"
215 }
216 if strings.HasPrefix(base, "readme") {
217 return "md"
218 }
219 return "file"
220}
221
222func ago(unix int64) string {
223 if unix <= 0 {
224 return ""
225 }
226 d := time.Since(time.Unix(unix, 0))
227 if d < time.Minute {
228 return "zojuist"
229 }
230 if d < time.Hour {
231 n := int(d.Minutes())
232 if n < 1 {
233 n = 1
234 }
235 if n == 1 {
236 return "1 minuut geleden"
237 }
238 return fmt.Sprintf("%d minuten geleden", n)
239 }
240 if d < 24*time.Hour {
241 n := int(d.Hours())
242 if n == 1 {
243 return "1 uur geleden"
244 }
245 return fmt.Sprintf("%d uur geleden", n)
246 }
247 days := int(d.Hours() / 24)
248 if days < 1 {
249 days = 1
250 }
251 if days == 1 {
252 return "1 dag geleden"
253 }
254 if days < 14 {
255 return fmt.Sprintf("%d dagen geleden", days)
256 }
257 if days < 60 {
258 n := days / 7
259 if n == 1 {
260 return "1 week geleden"
261 }
262 return fmt.Sprintf("%d weken geleden", n)
263 }
264 if days < 365 {
265 n := days / 30
266 if n < 1 {
267 n = 1
268 }
269 if n == 1 {
270 return "1 maand geleden"
271 }
272 return fmt.Sprintf("%d maanden geleden", n)
273 }
274 n := days / 365
275 if n == 1 {
276 return "1 jaar geleden"
277 }
278 return fmt.Sprintf("%d jaar geleden", n)
279}
280
281func dutchDate(t time.Time) string {
282 if t.IsZero() {
283 return ""
284 }
285 months := []string{"", "januari", "februari", "maart", "april", "mei", "juni", "juli", "augustus", "september", "oktober", "november", "december"}
286 t = t.Local()
287 return fmt.Sprintf("%d %s %d", t.Day(), months[t.Month()], t.Year())
288}
289
290func formatSize(n int64) string {
291 if n < 1024 {
292 return fmt.Sprintf("%d B", n)
293 }
294 if n < 1024*1024 {
295 return fmt.Sprintf("%.1f KiB", float64(n)/1024)
296 }
297 return fmt.Sprintf("%.1f MiB", float64(n)/(1024*1024))
298}