@uknows/setup 0.1.0 → 0.2.0

package/lib/context.mjs

@@ -0,0 +1,126 @@
+/*
+ * The build context of a Dockerfile, read from the repo: which folder `docker build` sends, where the app is in
+ * the image (the WORKDIR of the final stage), and whether .dockerignore leaves a file out. Static reading only.
+ * A wrong guess makes the build fail at COPY, so every function returns null when it is not sure.
+ */
+import { posix } from 'node:path'
+import { copySources } from './detect.mjs'
+
+const GLOB = /[*?[]/
+const dirOf = (path) => posix.dirname(path)
+const at = (dir, name) => (dir === '.' ? name : `${dir}/${name}`)
+const unique = (list) => [...new Set(list)]
+
+/**
+ * The folder that `docker build` sends for this Dockerfile: the Dockerfile folder, the service folder or the repo
+ * root. The COPY and ADD sources decide: a folder fits when every source that exists in any of these folders exists
+ * in it. Sources that exist nowhere (built before docker build runs) do not count. null unless exactly 1 folder fits.
+ * @param {Pick<import('./workspace.mjs').RepoView, 'exists'|'list'>} view
+ * @param {string} dockerfile  Repo path of the Dockerfile.
+ * @param {import('./dockerfile.mjs').DockerfileInfo} info
+ * @param {string} serviceDir
+ * @returns {string|null}
+ */
+export function buildContext(view, dockerfile, info, serviceDir) {
+  const candidates = unique([dirOf(dockerfile), serviceDir, '.'])
+  const sources = copySources(info).map((src) => src.replace(/^\/+/, '')).filter(Boolean)
+  const found = (dir, src) => present(view, dir, src)
+  const counted = sources.filter((src) => candidates.some((dir) => found(dir, src)))
+  const fits = candidates.filter((dir) => counted.every((src) => found(dir, src)))
+  return fits.length === 1 ? fits[0] : null
+}
+
+/** True when src exists in dir. A pattern (package*.json) counts when a name in its folder matches it. */
+function present(view, dir, src) {
+  const path = posix.normalize(at(dir, src))
+  if (path.startsWith('../') || path === '..') return false
+  if (!GLOB.test(path)) return view.exists(path)
+  const folder = dirOf(path)
+  if (GLOB.test(folder)) return false
+  const re = globRegex(posix.basename(path))
+  return view.list(folder).some((name) => re.test(name))
+}
+
+/**
+ * The WORKDIR of the final stage, with the stages it builds on (FROM <stage>). null when it is not set in the
+ * Dockerfile, uses a variable, or is relative to a WORKDIR of the base image.
+ * @param {import('./dockerfile.mjs').DockerfileInfo} info
+ * @returns {string|null}
+ */
+export function finalWorkdir(info) {
+  const chain = []
+  for (let i = info.stages.length - 1, hops = 0; i >= 0 && hops < 20; hops++) {
+    chain.unshift(info.stages[i])
+    const base = info.stages[i].image.toLowerCase()
+    i = info.stages.findLastIndex((s, j) => j < i && s.name?.toLowerCase() === base)
+  }
+  let dir = null
+  for (const x of chain.flatMap((stage) => stage.instructions).filter((y) => y.keyword === 'WORKDIR')) {
+    const value = x.args.trim().replace(/^(["'])(.*)\1$/, '$2')
+    if (!value || /[$\s]/.test(value)) return null
+    dir = value.startsWith('/') ? value : dir === null ? null : posix.join(dir, value)
+  }
+  return dir === null ? null : posix.normalize(dir).replace(/(?<=.)\/+$/, '')
+}
+
+/**
+ * The ignore file that leaves path (relative to the context) out of the build context, or null when none does.
+ * BuildKit reads <Dockerfile>.dockerignore next to the Dockerfile first. The legacy builder reads only
+ * .dockerignore in the context. Both count, so the file reaches the image with either builder.
+ * @param {Pick<import('./workspace.mjs').RepoView, 'read'>} view
+ * @param {string} context
+ * @param {string} dockerfile
+ * @param {string} path
+ * @returns {string|null}
+ */
+export function ignoredBy(view, context, dockerfile, path) {
+  for (const file of unique([`${dockerfile}.dockerignore`, at(context, '.dockerignore')])) {
+    let text = null
+    try { text = view.read(file) } catch { /* not readable */ }
+    if (text !== null && dockerIgnored(path, text)) return file
+  }
+  return null
+}
+
+/**
+ * True when the .dockerignore text leaves path out, as Docker reads it: 1 pattern per line, # comments, ! for an
+ * exception, ** for any number of folders. A pattern that matches a folder leaves out all files in it. The last
+ * pattern that matches wins.
+ * @param {string} path  Relative to the context, with '/'.
+ * @param {string} text
+ */
+export function dockerIgnored(path, text) {
+  const parts = path.split('/')
+  let ignored = false
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim()
+    if (!line || line.startsWith('#')) continue
+    const exception = line.startsWith('!')
+    const pattern = posix.normalize((exception ? line.slice(1) : line).trim().replace(/^\/+/, '')).replace(/\/+$/, '')
+    if (!pattern) continue
+    const re = pattern === '.' ? /^/ : globRegex(pattern)
+    if (parts.some((_, i) => re.test(parts.slice(0, i + 1).join('/')))) ignored = !exception
+  }
+  return ignored
+}
+
+/** A Docker path pattern as a regex: * and ? stay in 1 folder, ** crosses folders, [..] is a class. */
+function globRegex(pattern) {
+  let out = ''
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i]
+    if (ch === '*' && pattern[i + 1] === '*') {
+      const slash = pattern[i + 2] === '/'
+      out += slash ? '(?:.*/)?' : '.*'
+      i += slash ? 2 : 1
+    } else if (ch === '*') out += '[^/]*'
+    else if (ch === '?') out += '[^/]'
+    else if (ch === '[') {
+      const end = pattern.indexOf(']', i + 1)
+      if (end < 0) { out += '\\['; continue }
+      out += `[${pattern.slice(i + 1, end).replace(/^!/, '^').replace(/\\/g, '\\\\')}]`
+      i = end
+    } else out += ch.replace(/[.+^${}()|\\]/g, '\\$&')
+  }
+  return new RegExp(`^${out}$`)
+}