BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

feat: goedkeuringen, reviews en heropenen van een merge request
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
ad4c7e2d History
repo_handlers.go 17.2 KiB Download Raw
1package server
2
3import (
4 "net/http"
5 "strconv"
6 "strings"
7
8 "gitlab.com/Timfa/bluegit/internal/access"
9 "gitlab.com/Timfa/bluegit/internal/gitrepo"
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11 "gitlab.com/Timfa/bluegit/internal/names"
12 "gitlab.com/Timfa/bluegit/internal/store"
13)
14
15func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
16 owner := r.PathValue("owner")
17 name := strings.TrimSuffix(r.PathValue("repo"), ".git")
18 repo, err := s.Store.RepoByPath(r.Context(), owner, name)
19 if err != nil {
20 http.NotFound(w, r)
21 return store.User{}, store.Repo{}, "", false
22 }
23 p := s.who(r)
24 var role access.Role
25 if p.OK {
26 role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
27 if err != nil {
28 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
29 return store.User{}, store.Repo{}, "", false
30 }
31 }
32 readable := role.CanRead() || repo.Visibility == "public"
33 if !readable {
34 if p.OK {
35 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
36 } else {
37 http.NotFound(w, r)
38 }
39 return store.User{}, store.Repo{}, "", false
40 }
41 if min != access.RoleReadonly && !role.AtLeast(min) {
42 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
43 return store.User{}, store.Repo{}, "", false
44 }
45 return p.User, repo, role, true
46}
47
48func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
49 v := s.view(w, r, title)
50 v.Repo = &repo
51 v.Role = role
52 v.CanWrite = role.CanWriteCode()
53 v.CanAdmin = role.CanManageSettings()
54 v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
55 v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
56 v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
57 return v
58}
59
60func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
61 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
62 if !ok {
63 return
64 }
65 v := s.repoView(w, r, repo, role, repo.Name)
66 v.Wide = true
67 s.fillOverview(r, &v, repo)
68 v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}, s.langOf(r))
69 s.render(w, "repo", v)
70}
71
72func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
73 r.SetPathValue("path", "")
74 s.tree(w, r)
75}
76
77func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
78 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
79 if !ok {
80 return
81 }
82 rel, err := cleanRel(r.PathValue("path"))
83 if err != nil {
84 http.NotFound(w, r)
85 return
86 }
87 v := s.repoView(w, r, repo, role, rel)
88 v.Wide = true
89 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
90 if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
91 http.NotFound(w, r)
92 return
93 }
94 s.fillFiles(r, &v, repo, rel, false)
95 s.render(w, "files", v)
96}
97
98func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
99 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
100 if !ok {
101 return
102 }
103 rel, err := cleanRel(r.PathValue("path"))
104 if err != nil || rel == "" {
105 http.NotFound(w, r)
106 return
107 }
108 v := s.repoView(w, r, repo, role, rel)
109 v.Wide = true
110 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
111 if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
112 http.NotFound(w, r)
113 return
114 }
115 s.fillFiles(r, &v, repo, rel, true)
116 s.render(w, "files", v)
117}
118
119func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
120 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
121 if !ok {
122 return
123 }
124 v := s.repoView(w, r, repo, role, "title.commits")
125 v.Page = "commits"
126 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
127 list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
128 v.Commits = s.presentCommits(r.Context(), repo.ID, list, i18n.Parse(v.Lang))
129 s.render(w, "commits", v)
130}
131
132func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
133 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
134 if !ok {
135 return
136 }
137 sha := r.PathValue("sha")
138 if !safeSHA(sha) {
139 http.NotFound(w, r)
140 return
141 }
142 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
143 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
144 if err != nil {
145 http.NotFound(w, r)
146 return
147 }
148 v := s.repoView(w, r, repo, role, c.Subject)
149 rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, i18n.Parse(v.Lang))
150 v.Commit = &rows[0]
151 s.render(w, "commit", v)
152}
153
154func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
155 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
156 if !ok {
157 return
158 }
159 v := s.repoView(w, r, repo, role, "title.branches")
160 v.Page = "branches"
161 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
162 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
163 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
164 for _, name := range names {
165 v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
166 }
167 s.render(w, "branches", v)
168}
169
170func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
171 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
172 if !ok {
173 return
174 }
175 v := s.repoView(w, r, repo, role, "title.mrs")
176 v.Page = "mrs"
177 v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
178 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
179 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
180 for _, name := range names {
181 v.Branches = append(v.Branches, BranchRow{Name: name})
182 }
183 s.render(w, "mrs", v)
184}
185
186func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
187 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
188 if !ok || !s.csrfOK(w, r) {
189 return
190 }
191 if !role.CanWriteCode() {
192 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
193 return
194 }
195 source := safeRev(r.FormValue("source"), "")
196 target := safeRev(r.FormValue("target"), repo.DefaultBranch)
197 if source == "" || source == target {
198 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.tr(r, "err.branches"))
199 return
200 }
201 mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target)
202 if err != nil {
203 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.trErr(r, err))
204 return
205 }
206 num := strconv.FormatInt(mr.Number, 10)
207 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
208 if sha := gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
209 s.startOneMergePipeline(r.Context(), repo, sha, u.Username, "", mr)
210 }
211 s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, s.tr(r, "hook.mr", num, mr.Title), repoURL(repo)+"/-/merge-requests/"+num))
212 s.recordContribution(u.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
213 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
214}
215
216func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
217 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
218 if !ok {
219 return
220 }
221 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
222 if err != nil {
223 http.NotFound(w, r)
224 return
225 }
226 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
227 if err != nil {
228 http.NotFound(w, r)
229 return
230 }
231 v := s.repoView(w, r, repo, role, mr.Title)
232 v.MR = &mr
233 v.Wide = true
234 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
235 v.CanComment = role.AtLeast(access.RoleReadonly)
236 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
237 v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch))
238 v.MergeBlocks = s.mergeBlocks(r, repo, mr)
239 s.fillMRPipeline(r, &v, repo, mr)
240 s.fillReviews(r, &v, repo, mr, role)
241 if u.ID != 0 {
242 mine := u.ID == mr.AuthorID || role.CanManageSettings()
243 v.CanClose = mr.Status == "open" && mine
244 v.CanReopen = mr.Status == "closed" && mine
245 }
246 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
247 diff, err := gitrepo.DiffStat(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
248 if err == nil {
249 v.Diff = diff
250 }
251 files, _ := gitrepo.DiffFiles(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
252 notes, _ := s.Store.ListNotes(r.Context(), mr.ID)
253 v.Notes, v.DiffFiles = arrangeNotes(notes, files, s.langOf(r))
254 s.render(w, "mr", v)
255}
256
257func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
258 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
259 if !ok || !s.csrfOK(w, r) {
260 return
261 }
262 if u.ID == 0 || !role.AtLeast(access.RoleReadonly) {
263 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
264 return
265 }
266 mr, err := s.mrFromRequest(r, repo.ID)
267 if err != nil {
268 http.NotFound(w, r)
269 return
270 }
271 back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
272 path, pathOK := repoPath(r.FormValue("path"))
273 if !pathOK {
274 s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))
275 return
276 }
277 if path == "" {
278 if _, err := s.Store.AddNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body")); err != nil {
279 s.redirect(w, r, back, "", s.trErr(r, err))
280 return
281 }
282 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
283 return
284 }
285 start, _ := strconv.Atoi(r.FormValue("line_start"))
286 end, _ := strconv.Atoi(r.FormValue("line_end"))
287 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
288 blob, err := gitrepo.BlobText(r.Context(), s.Git, dir, mr.SourceBranch, path)
289 if err != nil {
290 s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))
291 return
292 }
293 lines := gitrepo.SplitLines(blob)
294 if start < 1 || end < start || end > len(lines) {
295 s.redirect(w, r, back, "", s.tr(r, "err.sugLines"))
296 return
297 }
298 base := strings.Join(lines[start-1:end], "\n")
299 suggestion, _ := gitrepo.ParseSuggestion(r.FormValue("body"))
300 if _, err := s.Store.AddLineNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body"), path, start, end, suggestion, base); err != nil {
301 s.redirect(w, r, back, "", s.trErr(r, err))
302 return
303 }
304 s.noteRequestsChanges(r, repo, mr, u.ID, suggestion)
305 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
306}
307
308func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
309 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
310 if !ok || !s.csrfOK(w, r) {
311 return
312 }
313 mr, err := s.mrFromRequest(r, repo.ID)
314 if err != nil || mr.Status != "open" {
315 http.NotFound(w, r)
316 return
317 }
318 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
319 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
320 http.Error(w, s.tr(r, "err.targetAccess"), http.StatusForbidden)
321 return
322 }
323 if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {
324 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", blocks[0])
325 return
326 }
327 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
328 before, _ := gitrepo.Refs(r.Context(), s.Git, dir)
329 work := s.StoragePath() + "/tmp/merge-" + strconv.FormatInt(mr.ID, 10)
330 email := u.Username + "@users.git.timfalken.com"
331 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
332 if err := gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns); err != nil {
333 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", s.trErr(r, err))
334 return
335 }
336 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged")
337 after, _ := gitrepo.Refs(r.Context(), s.Git, dir)
338 s.AfterPush(repo, u, before, after)
339 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.merged"), "")
340}
341
342func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
343 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
344 if !ok || !s.csrfOK(w, r) {
345 return
346 }
347 mr, err := s.mrFromRequest(r, repo.ID)
348 if err != nil {
349 http.NotFound(w, r)
350 return
351 }
352 if mr.AuthorID != u.ID && !role.CanManageSettings() {
353 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
354 return
355 }
356 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed")
357 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.closed"), "")
358}
359
360func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
361 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
362 if err != nil {
363 return store.MergeRequest{}, err
364 }
365 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
366}
367
368func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
369 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
370 if !ok {
371 return
372 }
373 if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" {
374 if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 {
375 http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther)
376 return
377 }
378 }
379 v := s.repoView(w, r, repo, role, "title.pipelines")
380 v.Wide = true
381 v.Page = "pipelines"
382 s.fillPipelines(r, &v, repo)
383 s.render(w, "pipelines", v)
384}
385
386func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
387 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
388 if !ok {
389 return
390 }
391 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
392 if err != nil {
393 http.NotFound(w, r)
394 return
395 }
396 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
397 if err != nil {
398 http.NotFound(w, r)
399 return
400 }
401 v := s.repoView(w, r, repo, role, "title.pipeline")
402 v.Wide = true
403 v.Page = "pipelines"
404 v.Pipe = &p
405 v.Jobs, _ = s.Store.JobsByPipeline(r.Context(), p.ID)
406 s.render(w, "pipeline", v)
407}
408
409func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
410 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
411 if !ok || !s.csrfOK(w, r) {
412 return
413 }
414 ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
415 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
416 shaOut, err := gitSHA(r, s.Git, dir, ref)
417 if err != nil {
418 s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", s.tr(r, "err.branchMissing"))
419 return
420 }
421 s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username, "web", "", nil)
422 s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
423}
424
425func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
426 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
427 if !ok {
428 return
429 }
430 v := s.repoView(w, r, repo, role, "title.releases")
431 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
432 s.render(w, "releases", v)
433}
434
435func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
436 u, ok := s.loginRequired(w, r)
437 if !ok || !s.csrfOK(w, r) {
438 return
439 }
440 if s.StoragePath() == "" {
441 msg := s.tr(r, "err.noStorage")
442 if wantsModal(r) {
443 writeModal(w, false, "", msg, http.StatusBadRequest)
444 return
445 }
446 s.redirect(w, r, "/", "", msg)
447 return
448 }
449 name, err := names.Slug("repo", r.FormValue("name"))
450 if err != nil {
451 s.failCreate(w, r, s.tr(r, "slug.bad"))
452 return
453 }
454 ownerKind := "user"
455 ownerID := u.ID
456 if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {
457 g, err := s.Store.GroupByPath(r.Context(), gpath)
458 if err != nil {
459 s.failCreate(w, r, s.tr(r, "err.groupMissing"))
460 return
461 }
462 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
463 if err != nil || !role.CanManageSettings() {
464 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
465 return
466 }
467 ownerKind, ownerID = "group", g.ID
468 }
469 vis := r.FormValue("visibility")
470 if vis != "public" {
471 vis = "private"
472 }
473 repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)
474 if err != nil {
475 s.failCreate(w, r, s.trErr(r, err))
476 return
477 }
478 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
479 if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
480 _ = s.Store.DeleteRepo(r.Context(), repo.ID)
481 s.failCreate(w, r, s.tr(r, "err.gitInit", err.Error()))
482 return
483 }
484 s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
485}
486
487func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
488 u, ok := s.loginRequired(w, r)
489 if !ok || !s.csrfOK(w, r) {
490 return
491 }
492 display := strings.TrimSpace(r.FormValue("name"))
493 path, err := names.Slug("group", display)
494 if err != nil {
495 s.failCreate(w, r, s.tr(r, "slug.bad"))
496 return
497 }
498 role := access.Role("")
499 if raw := strings.TrimSpace(r.FormValue("default_role")); raw != "" {
500 role, err = access.ParseRole(raw)
501 if err != nil {
502 s.failCreate(w, r, s.trErr(r, err))
503 return
504 }
505 }
506 g, err := s.Store.CreateGroup(r.Context(), u.ID, display, path, r.FormValue("description"), role)
507 if err != nil {
508 s.failCreate(w, r, s.trErr(r, err))
509 return
510 }
511 s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated"))
512}
513
514func toEntries(base string, in []gitrepo.Entry) []EntryRow {
515 var out []EntryRow
516 for _, e := range in {
517 p := e.Name
518 if base != "" {
519 p = base + "/" + e.Name
520 }
521 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
522 }
523 return out
524}
525
526func cleanRel(p string) (string, error) {
527 p = strings.TrimPrefix(p, "/")
528 if p == "" || p == "." {
529 return "", nil
530 }
531 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
532 return "", errBadID
533 }
534 return p, nil
535}
536
537func safeRev(s, fallback string) string {
538 if s == "" {
539 return fallback
540 }
541 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
542 return fallback
543 }
544 return s
545}
546
547func safeSHA(s string) bool {
548 if len(s) < 7 || len(s) > 64 {
549 return false
550 }
551 for _, c := range s {
552 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
553 return false
554 }
555 }
556 return true
557}