gitoria

29.2 KB

1. // git.hl — READING A REPO'S FILES for its homepage (ticket gitoria#8). Each repo is one BARE git
2. // repository, <gitRoot>/<slug>.git (created with the repo, repos.hl createRepo). Reads go through the
3. // `git` binary with hl:proc (docs/git-backend.md): an argv list, never a shell, the slug is
4. // validated by the caller (repos.hl slugError), a path only ever comes from `git ls-tree`.
5. // Every read calls git with hl:proc run() (hybriel#80: it waits), so the readers answer through their callback
6. // before they return; the page components use the `...Now` forms at construction (server-rendered, gitoria#16).
7. //
8. // THE HOMEPAGE (the creator, ticket #1): the repo's `/` shows README.md as a page; if there is a
9. // `$docs` folder, all Markdown files inside it form the homepage instead. Read from the repo's
10. // HEAD (its default branch; the setting to switch it comes with #9).
11. import { run, env, cwd } from 'hl:proc'
12. import { markdownBlocks } from './markdown.hl'
13. import { localStamp } from './localtime.hl'
15. static NL = "
16. "
18. // where the bare repositories live: GITORIA_GIT, else ./storage/git under the launch directory
19. static gitRoot = env('GITORIA_GIT') != null && env('GITORIA_GIT') != '' ? env('GITORIA_GIT') : cwd() + '/storage/git'
20. static repoDir = (slug) => { return gitRoot + '/' + slug + '.git' }
22. static maxFiles = 30 // Markdown files of a $docs folder
23. static maxLines = 5000 // lines of one file
24. static maxTree = 20000 // paths looked at
25. static seconds = 15 // one git call
27. // one git call: argv (after `git --git-dir=<dir>`), `done({ ok, lines })` exactly once — BEFORE git() returns:
28. // hl:proc run() waits for the program (hybriel#80), so a page's root can read git while it is built on the server
29. // and the callback style of the readers below is synchronous. Past `seconds` git is killed; run() is then an Error
30. // (absorbed by project.hl `on Error`) and yields null → ok = false.
31. static git = (slug, rest, limit, done) => {
32. let argv = ['git', '--git-dir=' + repoDir(slug), '-c', 'core.quotePath=false']
33. for (a of rest) { argv.push(a) }
34. let r = run(argv, { timeout = seconds })
35. let lines = []
36. if (r != null) {
37. for (l of r.lines) { if (lines.length < limit) { lines.push(l) } }
38. }
39. done({ ok = r != null && r.exit == 0 lines = lines })
40. return null
41. }
43. // the SYNCHRONOUS answers of the readers (git() calls back before it returns): what a page's root uses
44. static homepageNow = (slug, setting) => {
45. let out = { files = [] found = false truncated = false }
46. defaultBranch(slug, setting, (ref) => {
47. loadHomepage(slug, ref, (result) => {
48. out = result
49. return null
50. })
51. return null
52. })
53. return out
54. }
55. static browseNow = (slug, kind, rest, setting, owner) => {
56. let out = null
57. browse(slug, kind, rest, setting, owner, (result) => {
58. out = result
59. return null
60. })
61. return out
62. }
63. static pullsNow = (slug, setting) => {
64. let out = null
65. pulls(slug, setting, (result) => {
66. out = result
67. return null
68. })
69. return out
70. }
71. static releasesNow = (slug, setting) => {
72. let out = null
73. releases(slug, setting, (result) => {
74. out = result
75. return null
76. })
77. return out
78. }
80. // a path we let through: printable, no leading dash, no backslash / quote / control characters
81. static safePath = (path) => {
82. if (path == null || path == '' || path.length > 300 || path.startsWith('-')) { return false }
83. let i = 0
84. while (i < path.length) {
85. let c = path.charCodeAt(i)
86. if (c < 32 || c == 127 || c == 34 || c == 92 || c == 58) { return false }
87. i = i + 1
88. }
89. return true
90. }
92. static isMarkdown = (path) => { return path.toLowerCase().endsWith('.md') }
94. // the files that make the homepage: [] (none), or the paths in tree order
95. static homepagePaths = (tree) => {
96. let docs = []
97. let readme = null
98. for (path of tree) {
99. if (safePath(path)) {
100. if (path.startsWith('$docs/') && isMarkdown(path) && docs.length < maxFiles) { docs.push(path) }
101. if (readme == null && !path.includes('/') && path.toLowerCase() == 'readme.md') { readme = path }
102. }
103. }
104. if (docs.length > 0) { return docs }
105. return readme != null ? [readme] : []
106. }
108. // the homepage of a branch (its ref) → done({ files: [{ path, isDocs, blocks }], found, truncated })
109. static loadHomepage = (slug, ref, done) => {
110. if (ref == null) {
111. done({ files = [] found = false truncated = false })
112. return null
113. }
114. git(slug, ['ls-tree', '-r', '--name-only', ref], maxTree, (t) => {
115. let paths = t.ok ? homepagePaths(t.lines) : []
116. let files = []
117. let truncated = false
118. let next = (i) => {
119. if (i >= paths.length) {
120. done({ files = files found = files.length > 0 truncated = truncated })
121. return null
122. }
123. git(slug, ['cat-file', 'blob', ref + ':' + paths[i]], maxLines + 1, (r) => {
124. if (r.ok) {
125. if (r.lines.length > maxLines) { truncated = true }
126. let lines = r.lines.length > maxLines ? r.lines.slice(0, maxLines) : r.lines
127. files.push({ path = paths[i] isDocs = paths[i].startsWith('$docs/') blocks = markdownBlocks(lines.join(NL)) })
128. }
129. next(i + 1)
130. return null
131. })
132. return null
133. }
134. next(0)
135. return null
136. })
137. }
139. // ---- BROWSING CODE (ticket gitoria#9): /code, /branch/<name>, /commit/<id> ----------------------
140. // /code = the repo's main branch (the owner's setting, else `main`, else the first branch);
141. // /branch/<name> = that branch at its last commit; /commit/<id> = the whole project at that commit.
142. // Behind each: the folder tree, a file's lines, the branches, the latest commits.
143. // a line of valid UTF-8, as bytes (@ stands for a backslash: a string ending in a backslash cannot be written, so it is cut from '\u005cx')
144. static utf8Line = '^(?:[@x00-@x7F]|[@xC2-@xDF][@x80-@xBF]|@xE0[@xA0-@xBF][@x80-@xBF]|[@xE1-@xEC@xEE@xEF][@x80-@xBF]{2}|@xED[@x80-@x9F][@x80-@xBF]|@xF0[@x90-@xBF][@x80-@xBF]{2}|[@xF1-@xF3][@x80-@xBF]{3}|@xF4[@x80-@x8F][@x80-@xBF]{2})*$'.replaceAll('@', '\u005cx'.slice(0, 1))
145. static maxBrowseLines = 2000
146. static maxBlobBytes = 1000000
147. static maxCommits = 20
149. // a URL path piece: percent-encoded, the slashes kept (encodeURIComponent is a global since hybriel #14)
150. static enc = (s) => { return encodeURIComponent(s).replaceAll('%2F', '/') }
152. static isHexId = (s) => {
153. if (s == null || s.length < 4 || s.length > 40) { return false }
154. let i = 0
155. while (i < s.length) {
156. let c = s.charCodeAt(i)
157. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 102))) { return false }
158. i = i + 1
159. }
160. return true
161. }
163. static safeName = (n) => { return safePath(n) && n.length <= 100 && !n.endsWith('/') && !n.includes('//') }
165. // the branch names of a repo → done([name])
166. static branchNames = (slug, done) => {
167. git(slug, ['for-each-ref', '--format=%(refname:short)', 'refs/heads'], 500, (r) => {
168. let out = []
169. if (r.ok) { for (l of r.lines) { if (safeName(l)) { out.push(l) } } }
170. done(out)
171. return null
172. })
173. }
175. // which branch is "main" for a repo: the setting if it exists, else `main`, else the first one; null = no branch
176. static pickDefault = (names, setting) => {
177. if (setting != null && setting != '' && names.includes(setting)) { return setting }
178. if (names.includes('main')) { return 'main' }
179. return names.length > 0 ? names[0] : null
180. }
182. static defaultBranch = (slug, setting, done) => {
183. branchNames(slug, (names) => {
184. done(pickDefault(names, setting))
185. return null
186. })
187. }
189. static sizeText = (n) => {
190. if (n < 1024) { return n + ' B' }
191. let unit = n < 1048576 ? 1024 : 1048576
192. let t = (n * 10 - (n * 10) % unit) / unit
193. return ((t - t % 10) / 10) + '.' + (t % 10) + (n < 1048576 ? ' KB' : ' MB')
194. }
196. // which view a page path is: { view: 'home' | 'code' | 'tickets' | 'pulls' | 'releases', kind, rest }
197. static parseView = (path) => {
198. let none = { view = 'home' kind = '' rest = '' }
199. if (path == null || hlTypeName(path) != 'String' || path.length > 500 || path.slice(0, 1) != '/') { return none }
200. let body = path.slice(1)
201. let slash = body.indexOf('/')
202. let head = slash < 0 ? body : body.slice(0, slash)
203. let rest = slash < 0 ? '' : body.slice(slash + 1)
204. if (head == 'code' || head == 'branch' || head == 'commit') { return { view = 'code' kind = head rest = rest } }
205. if (head == 'tickets' && rest == '') { return { view = 'tickets' kind = '' rest = '' } }
206. if (head == 'pulls' && rest == '') { return { view = 'pulls' kind = '' rest = '' } }
207. if (head == 'releases' && rest == '') { return { view = 'releases' kind = '' rest = '' } }
208. return none
209. }
211. // tab-separated fields of a line git wrote. (split() / indexOf() do not find a tab in a line that
212. // came from hl:proc, so scan by character code.)
213. static tabAt = (line) => {
214. let i = 0
215. while (i < line.length) {
216. if (line.charCodeAt(i) == 9) { return i }
217. i = i + 1
218. }
219. return -1
220. }
221. static tabs = (line) => {
222. let out = []
223. let start = 0
224. let i = 0
225. while (i < line.length) {
226. if (line.charCodeAt(i) == 9) {
227. out.push(line.slice(start, i))
228. start = i + 1
229. }
230. i = i + 1
231. }
232. out.push(line.slice(start))
233. return out
234. }
236. // the answer's fixed shape: the page reads these names, whatever the state
237. static shape = (state, message) => {
238. return { state = state isMessage = message != '' message = message isTree = false isFile = false refLabel = '' kindLabel = ''
239. sha = '' short = '' commitHref = '' subject = '' author = '' date = '' hasCrumbs = false crumbs = [] entries = [] noEntries = false lines = [] binary = false tooBig = false truncated = false fileSize = ''
240. branches = [] commits = [] hasCommits = false defaultName = '' isCommitView = false canSet = false }
241. }
243. // the answer for one view → done(result). kind: 'code' | 'branch' | 'commit'; rest = what follows in the URL;
244. // setting = the repo's saved main branch ('' = none); owner = the viewer may change it
245. static browse = (slug, kind, rest, setting, owner, done) => {
246. let segs = []
247. for (x of rest.split('/')) { if (x != '') { segs.push(x) } }
248. branchNames(slug, (names) => {
249. if (names.length == 0) {
250. done(shape('empty', 'This repository has no commits yet. See the Code page to find out how to push code.'))
251. return null
252. }
253. let dflt = pickDefault(names, setting)
254. let ref = null
255. let label = ''
256. let base = ''
257. let pathSegs = segs
258. let sha = ''
259. let go = () => {
260. let path = pathSegs.join('/')
261. let bad = false
262. for (sg of pathSegs) { if (sg == '.' || sg == '..' || !safePath(sg)) { bad = true } }
263. if (bad) {
264. done(shape('nopath', 'No such path in ' + label + '.'))
265. return null
266. }
267. let here = (p) => { return p == '' ? (kind == 'code' ? '/code' : base.slice(0, base.length - 1)) : base + enc(p) }
268. let branchLinks = []
269. for (n of names) { branchLinks.push({ name = n href = '/branch/' + enc(n) isDefault = n == dflt isCurrent = kind == 'branch' && n == label notCurrent = !(kind == 'branch' && n == label) canSet = owner && n != dflt }) }
270. git(slug, ['log', '-' + maxCommits, '--format=%H%x09%ct%x09%an%x09%s', ref], maxCommits, (lg) => {
271. let commits = []
272. for (l of lg.lines) {
273. let f = tabs(l)
274. if (f.length >= 4) {
275. let sub = f.slice(3).join(' ')
276. commits.push({ sha = f[0] short = f[0].slice(0, 8) date = localStamp(toNumber(f[1]) * 1000) author = f[2] subject = sub href = '/commit/' + f[0] })
277. }
278. }
279. if (commits.length == 0) {
280. done(shape('empty', 'This repository has no commits yet. See the Code page to find out how to push code.'))
281. return null
282. }
283. let r = shape('ok', '')
284. r.refLabel = label
285. r.kindLabel = kind == 'commit' ? 'Commit' : (kind == 'code' ? 'Main branch' : 'Branch')
286. r.isCommitView = kind == 'commit'
287. r.sha = commits[0].sha
288. r.short = commits[0].short
289. r.commitHref = '/commit/' + commits[0].sha
290. r.subject = commits[0].subject
291. r.author = commits[0].author
292. r.date = commits[0].date
293. r.branches = branchLinks
294. r.commits = commits
295. r.hasCommits = true
296. r.defaultName = dflt
297. r.canSet = owner
298. let crumbs = [{ name = label href = here('') last = path == '' linked = path != '' }]
299. let acc = ''
300. let ci = 0
301. while (ci < pathSegs.length) {
302. acc = acc == '' ? pathSegs[ci] : acc + '/' + pathSegs[ci]
303. crumbs.push({ name = pathSegs[ci] href = here(acc) last = ci == pathSegs.length - 1 linked = ci != pathSegs.length - 1 })
304. ci = ci + 1
305. }
306. r.crumbs = crumbs
307. r.hasCrumbs = true
308. let spec = ref + ':' + path
309. git(slug, ['cat-file', '-t', spec], 1, (ty) => {
310. let t = ty.ok && ty.lines.length > 0 ? ty.lines[0] : ''
311. if (t == 'tree') {
312. git(slug, ['ls-tree', '-l', spec], maxTree, (ls) => {
313. let dirs = []
314. let files = []
315. for (l of ls.ok ? ls.lines : []) {
316. let tab = tabAt(l)
317. if (tab > 0) {
318. let meta = []
319. for (m of l.slice(0, tab).split(' ')) { if (m != '') { meta.push(m) } }
320. let name = l.slice(tab + 1)
321. if (meta.length >= 3 && safePath(name)) {
322. let full = path == '' ? name : path + '/' + name
323. let isDir = meta[1] == 'tree'
324. let isBlob = meta[1] == 'blob'
325. let e = { name = name isDir = isDir isFile = isBlob isOther = !isDir && !isBlob href = (isDir || isBlob) ? here(full) : '' size = (isBlob && meta.length >= 4 && meta[3] != '-') ? sizeText(toNumber(meta[3])) : '' isSub = meta[1] == 'commit' }
326. if (isDir) { dirs.push(e) } else { files.push(e) }
327. }
328. }
329. }
330. for (e of files) { dirs.push(e) }
331. r.isTree = true
332. r.entries = dirs
333. r.noEntries = dirs.length == 0
334. done(r)
335. return null
336. })
337. } else {
338. if (t == 'blob') {
339. git(slug, ['cat-file', '-s', spec], 1, (sz) => {
340. let bytes = sz.ok && sz.lines.length > 0 ? toNumber(sz.lines[0]) : 0
341. r.isFile = true
342. r.fileSize = sizeText(bytes)
343. if (bytes > maxBlobBytes) {
344. r.tooBig = true
345. done(r)
346. return null
347. }
348. // only UTF-8 text is read as lines: any other bytes cannot travel to the page. git's own verdict
349. // for text (`grep -I`), then a PCRE check that every line is valid UTF-8 (`-v` finds the others).
350. git(slug, ['--literal-pathspecs', 'grep', '-I', '-l', '-e', '', ref, '--', path], 1, (tx) => {
351. if (bytes == 0) {
352. done(r)
353. return null
354. }
355. if (!tx.ok) {
356. r.binary = true
357. done(r)
358. return null
359. }
360. git(slug, ['--literal-pathspecs', 'grep', '-I', '-P', '-v', '-c', '-e', utf8Line, ref, '--', path], 1, (bad) => {
361. if (bad.ok) {
362. r.binary = true
363. done(r)
364. return null
365. }
366. git(slug, ['cat-file', 'blob', spec], maxBrowseLines + 1, (b) => {
367. let lines = []
368. let n = 1
369. for (l of b.ok ? b.lines : []) {
370. if (n <= maxBrowseLines) { lines.push({ n = n text = l }) }
371. n = n + 1
372. }
373. if (n - 1 > maxBrowseLines) { r.truncated = true }
374. r.lines = lines
375. done(r)
376. return null
377. })
378. return null
379. })
380. return null
381. })
382. return null
383. })
384. } else {
385. done(shape('nopath', 'No such path in ' + label + '.'))
386. }
387. }
388. return null
389. })
390. return null
391. })
392. return null
393. }
394. if (kind == 'code') {
395. ref = dflt
396. label = dflt
397. base = '/code/'
398. go()
399. return null
400. }
401. if (kind == 'branch') {
402. let k = segs.length
403. while (k >= 1 && ref == null) {
404. let cand = segs.slice(0, k).join('/')
405. if (names.includes(cand)) {
406. ref = cand
407. label = cand
408. pathSegs = segs.slice(k)
409. }
410. k = k - 1
411. }
412. if (ref == null) {
413. done(shape('nobranch', segs.length == 0 ? 'Choose a branch.' : "This repository has no branch '" + segs.join('/') + "'."))
414. return null
415. }
416. base = '/branch/' + enc(ref) + '/'
417. go()
418. return null
419. }
420. // a commit
421. if (segs.length == 0 || !isHexId(segs[0])) {
422. done(shape('nocommit', 'No such commit.'))
423. return null
424. }
425. git(slug, ['rev-parse', '--verify', '--quiet', segs[0] + '^{commit}'], 1, (rp) => {
426. if (!rp.ok || rp.lines.length == 0 || !isHexId(rp.lines[0]) || rp.lines[0].length != 40) {
427. done(shape('nocommit', "No commit '" + segs[0] + "' in this repository."))
428. return null
429. }
430. sha = rp.lines[0]
431. ref = sha
432. label = sha.slice(0, 8)
433. base = '/commit/' + sha + '/'
434. pathSegs = segs.slice(1)
435. go()
436. return null
437. })
438. })
439. }
441. // ---- PULL REQUESTS (ticket gitoria#11): /pulls -------------------------------------------------
442. // A pull request is a COMMIT whose subject starts `|||PR ` (target = the repo's main branch) or
443. // `|||PR|<branch>] ` (target = <branch>). Nothing is stored: the list is read from git each time.
444. // Title = the text after the marker (else the source branch's name). Source = the branch holding the
445. // commit that is not the target. State: `merged` when the commit is in the target branch, else `open`.
446. // One request per source branch (its newest marker commit). Merging happens with git itself (push to the target).
447. static maxPulls = 50
448. static pullScan = 500
450. // a commit subject → null (not a request) or { target: '' (= default) | name, title }
451. static parsePull = (subject) => {
452. if (subject == null) { return null }
453. if (subject == '|||PR') { return { target = '' title = '' } }
454. if (subject.startsWith('|||PR ')) { return { target = '' title = subject.slice(6).trim() } }
455. if (subject.startsWith('|||PR|')) {
456. let close = subject.indexOf(']')
457. if (close < 7) { return null }
458. let target = subject.slice(6, close)
459. let rest = subject.slice(close + 1)
460. if (rest != '' && !rest.startsWith(' ')) { return null }
461. if (!safeName(target)) { return null }
462. return { target = target title = rest.trim() }
463. }
464. return null
465. }
467. static pullShape = (state, message) => {
468. return { state = state isMessage = message != '' message = message pulls = [] hasPulls = false noPulls = false defaultName = '' openCount = 0 mergedCount = 0 }
469. }
471. // every pull request of a repo → done(result). setting = the repo's saved main branch ('' = none)
472. static pulls = (slug, setting, done) => {
473. branchNames(slug, (names) => {
474. if (names.length == 0) {
475. done(pullShape('empty', 'This repository has no commits yet.'))
476. return null
477. }
478. let dflt = pickDefault(names, setting)
479. git(slug, ['log', '-' + pullScan, '--branches', '--format=%H%x09%ct%x09%an%x09%s'], pullScan, (lg) => {
480. let found = []
481. for (l of lg.ok ? lg.lines : []) {
482. let f = tabs(l)
483. if (f.length >= 4) {
484. let sub = f.slice(3).join(' ')
485. let pr = parsePull(sub)
486. if (pr != null && isHexId(f[0]) && found.length < maxPulls) {
487. found.push({ sha = f[0] short = f[0].slice(0, 8) date = localStamp(toNumber(f[1]) * 1000) author = f[2] target = pr.target == '' ? dflt : pr.target title = pr.title })
488. }
489. }
490. }
491. let out = pullShape('ok', '')
492. out.defaultName = dflt
493. let seen = []
494. let next = (i) => {
495. if (i >= found.length) {
496. out.hasPulls = out.pulls.length > 0
497. out.noPulls = out.pulls.length == 0
498. done(out)
499. return null
500. }
501. let c = found[i]
502. git(slug, ['for-each-ref', '--contains', c.sha, '--format=%(refname:short)', 'refs/heads'], 500, (ct) => {
503. let source = ''
504. for (n of ct.ok ? ct.lines : []) { if (source == '' && safeName(n) && n != c.target) { source = n } }
505. if (source != '' && seen.includes(source)) {
506. next(i + 1)
507. return null
508. }
509. if (source != '') { seen.push(source) }
510. let finish = (merged, targetMissing) => {
511. let title = c.title != '' ? c.title : (source != '' ? source : c.short)
512. out.pulls.push({ sha = c.sha short = c.short href = '/commit/' + c.sha title = title source = source hasSource = source != '' noSource = source == '' sourceHref = source != '' ? '/branch/' + enc(source) : '' target = c.target targetHref = targetMissing ? '' : '/branch/' + enc(c.target) targetLinked = !targetMissing state = merged ? 'merged' : 'open' isMerged = merged isOpen = !merged mergeable = !merged && source != '' && !targetMissing targetMissing = targetMissing author = c.author date = c.date })
513. if (merged) { out.mergedCount = out.mergedCount + 1 } else { out.openCount = out.openCount + 1 }
514. next(i + 1)
515. return null
516. }
517. if (!names.includes(c.target)) { return finish(false, true) }
518. git(slug, ['merge-base', '--is-ancestor', c.sha, c.target], 1, (mb) => {
519. return finish(mb.ok, false)
520. })
521. return null
522. })
523. return null
524. }
525. next(0)
526. return null
527. })
528. })
529. }
531. // the rows with `canMerge` (the owner, an open request whose branches exist) and the button's class: an `if` inside a
532. // `for` row is not re-evaluated when the list is reassigned (the old button stayed), an attribute is — so the button
533. // is always there and `.nomerge` hides it (styles.hl)
534. static withMerge = (list, owner) => {
535. let out = []
536. for (p of list) {
537. let q = p
538. q.canMerge = owner && p.mergeable
539. q.mergeClass = q.canMerge ? 'quiet mergepr' : 'nomerge'
540. out.push(q)
541. }
542. return out
543. }
545. // ---- MERGE a pull request (ticket gitoria#17): only when the owner clicks the button ---------------------------
546. // The repo is BARE (no work tree), so the merge is made with plumbing: `merge-tree --write-tree` merges the two
547. // branches into a tree (exit 1 = conflict: nothing is written to any branch), `commit-tree` makes the merge commit
548. // (parents: target, source), `update-ref` moves the target — with the old value given, so a push that arrived meanwhile
549. // makes it fail instead of being overwritten. Always a merge commit (like GitHub's "Create a merge commit").
550. // The pull request is found again on the SERVER by the sha of its `|||PR` commit (the client only names that).
551. // → { ok } | { error }. who = the user's name (author of the merge commit).
552. static gitRaw = (slug, rest) => {
553. let argv = ['git', '--git-dir=' + repoDir(slug), '-c', 'core.quotePath=false']
554. for (a of rest) { argv.push(a) }
555. return run(argv, { timeout = seconds })
556. }
558. static mergePullNow = (slug, setting, sha, who) => {
559. let found = null
560. if (sha == null || hlTypeName(sha) != 'String' || !isHexId(sha) || sha.length != 40) { return { error = 'no such pull request' } }
561. let got = pullsNow(slug, setting)
562. if (got == null || got.isMessage) { return { error = 'no such pull request' } }
563. for (p of got.pulls) { if (p.sha == sha) { found = p } }
564. if (found == null) { return { error = 'no such pull request' } }
565. if (found.isMerged) { return { error = 'this pull request is already merged' } }
566. if (found.noSource) { return { error = 'the branch of this pull request is gone' } }
567. if (found.targetMissing) { return { error = 'the target branch ' + found.target + ' does not exist' } }
568. let target = 'refs/heads/' + found.target
569. let old = gitRaw(slug, ['rev-parse', '--verify', '-q', target])
570. let tip = gitRaw(slug, ['rev-parse', '--verify', '-q', 'refs/heads/' + found.source])
571. if (old == null || old.exit != 0 || old.lines.length == 0 || tip == null || tip.exit != 0 || tip.lines.length == 0) { return { error = 'could not read the branches' } }
572. let oldSha = old.lines[0]
573. let tipSha = tip.lines[0]
574. if (!isHexId(oldSha) || !isHexId(tipSha)) { return { error = 'could not read the branches' } }
575. let m = gitRaw(slug, ['merge-tree', '--write-tree', '--name-only', '--no-messages', oldSha, tipSha])
576. if (m == null) { return { error = 'could not merge (git did not answer)' } }
577. if (m.exit == 1) {
578. let files = []
579. let i = 1
580. while (i < m.lines.length && m.lines[i] != '') {
581. if (files.length < 5) { files.push(m.lines[i]) }
582. i = i + 1
583. }
584. return { error = 'Not merged: ' + found.source + ' conflicts with ' + found.target + (files.length > 0 ? ' in ' + files.join(', ') : '') + '. Resolve it with git, then push.' }
585. }
586. if (m.exit != 0 || m.lines.length == 0 || !isHexId(m.lines[0])) { return { error = 'could not merge' } }
587. let name = who != null && who != '' ? who : 'gitoria'
588. let msg = "Merge branch '" + found.source + "' into " + found.target
589. let c = gitRaw(slug, ['-c', 'user.name=' + name, '-c', 'user.email=noreply@gitoria', 'commit-tree', m.lines[0], '-p', oldSha, '-p', tipSha, '-m', msg])
590. if (c == null || c.exit != 0 || c.lines.length == 0 || !isHexId(c.lines[0])) { return { error = 'could not write the merge commit' } }
591. let u = gitRaw(slug, ['update-ref', '-m', msg, target, c.lines[0], oldSha])
592. if (u == null || u.exit != 0) { return { error = 'The branch ' + found.target + ' changed meanwhile — nothing merged, try again.' } }
593. return { ok = true }
594. }
596. // ---- RELEASES (ticket gitoria#12): /releases ---------------------------------------------------
597. // A release is a COMMIT on the repo's main branch whose subject starts `|||RL ` (patch +1), `|||RL|med `
598. // (minor +1, patch 0), `|||RL|mj ` (major +1, minor and patch 0) or `|||RL|<version> ` (set by hand,
599. // e.g. 1.1.1a). Nothing is stored: the main branch's history is read oldest → newest and the versions are
600. // counted up from 0.0.0 (so the first `|||RL ` is 0.0.1). A hand-set version that was released before
601. // is not a release. A release = its version, the text after the marker, the commit (link), author, date.
602. static maxReleases = 200
603. static releaseScan = 5000
605. static isDigits = (s) => {
606. if (s == '' || s.length > 9) { return false }
607. let i = 0
608. while (i < s.length) {
609. let c = s.charCodeAt(i)
610. if (c < 48 || c > 57) { return false }
611. i = i + 1
612. }
613. return true
614. }
616. // the part of a version after its patch digits: only letters, digits, `.` and `-`
617. static suffixOk = (s) => {
618. let i = 0
619. while (i < s.length) {
620. let c = s.charCodeAt(i)
621. if (!((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c == 45 || c == 46)) { return false }
622. i = i + 1
623. }
624. return true
625. }
627. // `1.2.3` or `1.2.3a` → { major, minor, patch, text } or null
628. static parseVersion = (t) => {
629. if (t == null || t.length > 32) { return null }
630. let parts = t.split('.')
631. if (parts.length < 3) { return null }
632. if (!isDigits(parts[0]) || !isDigits(parts[1])) { return null }
633. let rest = parts.slice(2).join('.')
634. let n = 0
635. while (n < rest.length && rest.charCodeAt(n) >= 48 && rest.charCodeAt(n) <= 57) { n = n + 1 }
636. if (n == 0 || n > 9 || !suffixOk(rest.slice(n))) { return null }
637. return { major = toNumber(parts[0]) minor = toNumber(parts[1]) patch = toNumber(rest.slice(0, n)) text = t }
638. }
640. // a commit subject → null (not a release) or { kind: 'patch' | 'med' | 'mj' | 'set', version, title }
641. static parseRelease = (subject) => {
642. if (subject == null) { return null }
643. if (subject == '|||RL') { return { kind = 'patch' version = null title = '' } }
644. if (subject.startsWith('|||RL ')) { return { kind = 'patch' version = null title = subject.slice(6).trim() } }
645. if (subject.startsWith('|||RL|')) {
646. let body = subject.slice(6)
647. let sp = body.indexOf(' ')
648. let token = sp < 0 ? body : body.slice(0, sp)
649. let title = sp < 0 ? '' : body.slice(sp + 1).trim()
650. if (token == 'med') { return { kind = 'med' version = null title = title } }
651. if (token == 'mj') { return { kind = 'mj' version = null title = title } }
652. let v = parseVersion(token)
653. if (v == null) { return null }
654. return { kind = 'set' version = v title = title }
655. }
656. return null
657. }
659. static releaseShape = (state, message) => {
660. return { state = state isMessage = message != '' message = message releases = [] hasReleases = false noReleases = false defaultName = '' latest = '' }
661. }
663. // every release of a repo → done(result). setting = the repo's saved main branch ('' = none)
664. static releases = (slug, setting, done) => {
665. branchNames(slug, (names) => {
666. if (names.length == 0) {
667. done(releaseShape('empty', 'This repository has no commits yet.'))
668. return null
669. }
670. let dflt = pickDefault(names, setting)
671. git(slug, ['log', '--topo-order', '--reverse', '--fixed-strings', '--grep=|||RL', '--format=%H%x09%ct%x09%an%x09%s', dflt, '--'], releaseScan, (lg) => {
672. let out = releaseShape('ok', '')
673. out.defaultName = dflt
674. let major = 0
675. let minor = 0
676. let patch = 0
677. let seen = []
678. let oldest = []
679. for (l of lg.ok ? lg.lines : []) {
680. let f = tabs(l)
681. if (f.length >= 4 && isHexId(f[0])) {
682. let r = parseRelease(f.slice(3).join(' '))
683. if (r != null) {
684. let nmaj = major
685. let nmin = minor
686. let npat = patch
687. let text = ''
688. if (r.kind == 'patch') { npat = patch + 1 }
689. if (r.kind == 'med') { nmin = minor + 1 npat = 0 }
690. if (r.kind == 'mj') { nmaj = major + 1 nmin = 0 npat = 0 }
691. if (r.kind == 'set') { nmaj = r.version.major nmin = r.version.minor npat = r.version.patch text = r.version.text }
692. if (text == '') { text = nmaj + '.' + nmin + '.' + npat }
693. if (!seen.includes(text)) {
694. seen.push(text)
695. major = nmaj
696. minor = nmin
697. patch = npat
698. oldest.push({ version = text sha = f[0] short = f[0].slice(0, 8) href = '/commit/' + f[0] title = r.title hasTitle = r.title != '' noTitle = r.title == '' author = f[2] date = localStamp(toNumber(f[1]) * 1000) isLatest = false })
699. }
700. }
701. }
702. }
703. let i = oldest.length - 1
704. while (i >= 0 && out.releases.length < maxReleases) {
705. let rel = oldest[i]
706. rel.isLatest = i == oldest.length - 1
707. out.releases.push(rel)
708. i = i - 1
709. }
710. if (out.releases.length > 0) { out.latest = out.releases[0].version }
711. out.hasReleases = out.releases.length > 0
712. out.noReleases = out.releases.length == 0
713. done(out)
714. return null
715. })
716. })
717. }
719. // a new empty bare repository for a repo (a failure is not fatal: a repo without one just has no files)
720. static initRepo = (slug) => {
721. return run(['git', 'init', '--bare', '-q', '-b', 'main', repoDir(slug)], { timeout = seconds })
722. }
724. // does the repo have no branch yet (nothing pushed)? — the "how to add code" box opens itself then (gitoria#7)
725. static isEmptyNow = (slug) => {
726. let empty = true
727. git(slug, ['for-each-ref', '--count=1', 'refs/heads'], 1, (r) => {
728. empty = !r.ok || r.lines.length == 0
729. return null
730. })
731. return empty
732. }