@antora/content-aggregator 3.2.0-alpha.6 → 3.2.0-alpha.8

package/lib/aggregate-content.js

@@ -100,12 +100,12 @@ function aggregateContent (playbook) {
     const sourcesByUrl = sources.reduce((accum, source) => {
       return accum.set(source.url, [...(accum.get(source.url) || []), Object.assign({}, sourceDefaults, source)])
     }, new Map())
-    const progress = !quiet && createProgress(sourcesByUrl.keys(), process.stdout)
+    const progress = quiet ? undefined : createProgress(sourcesByUrl.keys(), process.stdout)
     const refPatternCache = Object.assign(new Map(), { braces: new Map() })
     const fetchConfig = { always: fetch, depth: Math.max(0, gitConfig.fetchDepth ?? 1) }
     const loadOpts = { cacheDir, fetch: fetchConfig, gitPlugins, progress, startDir, refPatternCache }
     return collectFiles(sourcesByUrl, loadOpts, concurrency).then(buildAggregate, (err) => {
-      progress && progress.terminate()
+      progress?.terminate()
       throw err
     })
   })
@@ -125,7 +125,7 @@ async function collectFiles (sourcesByUrl, loadOpts, concurrency, fetchedUrls =
         const msg0 = 'An unexpected error occurred while fetching content sources concurrently.'
         const msg1 = 'Retrying with git.fetch_concurrency value of 1.'
         logger.warn(rejections[0], msg0 + ' ' + msg1)
-        const fulfilledUrls = results.map((it) => it && it.repo.url && it.url).filter((it) => it)
+        const fulfilledUrls = results.filter((it) => it?.repo.url).map((it) => it.url)
         return collectFiles(sourcesByUrl, loadOpts, Object.assign(concurrency, { fetch: 1 }), fulfilledUrls)
       }
       throw rejections[0]
@@ -182,12 +182,12 @@ async function loadRepository (url, opts, result = {}) {
             return git.setConfig(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
           })
           .catch((fetchErr) => {
-            if (fetchOpts.onProgress) fetchOpts.onProgress.finish(fetchErr)
+            fetchOpts.onProgress?.finish(fetchErr)
             if (HTTP_ERROR_CODE_RX.test(fetchErr.code) && fetchErr.data.statusCode === 401) fetchErr.rethrow = true
             throw fetchErr
           })
           .then(() => fsp.writeFile(validStateFile, '').catch(invariably.void))
-          .then(() => fetchOpts.onProgress && fetchOpts.onProgress.finish())
+          .then(() => fetchOpts.onProgress?.finish())
       } else {
         authStatus = await git.getConfig(Object.assign({ path: 'remote.origin.private' }, repo))
       }
@@ -203,12 +203,12 @@ async function loadRepository (url, opts, result = {}) {
           return git.setConfig(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
         })
         .catch((cloneErr) => {
-          if (fetchOpts.onProgress) fetchOpts.onProgress.finish(cloneErr)
+          fetchOpts.onProgress?.finish(cloneErr)
           const authRequested = credentialManager.status({ url }) === 'requested'
           throw transformGitCloneError(cloneErr, displayUrl, authRequested)
         })
         .then(() => fsp.writeFile(validStateFile, '').catch(invariably.void))
-        .then(() => fetchOpts.onProgress && fetchOpts.onProgress.finish())
+        .then(() => fetchOpts.onProgress?.finish())
     }
   } else if (await isDirectory((dir = expandPath(url, { dot: opts.startDir })))) {
     const dotgit = ospath.join(dir, '.git')
@@ -244,11 +244,9 @@ function extractCredentials (url) {
     // NOTE if only username is present, assume it's an oauth token and set password to empty string
     const credentials = username ? { username, password: password || '' } : {}
     return { displayUrl, url, credentials }
-  } else if (url.startsWith('git@')) {
-    return { displayUrl: url, url: 'https://' + url.substr(4).replace(':', '/') }
-  } else {
-    return { displayUrl: url, url }
   }
+  if (url.startsWith('git@')) return { displayUrl: url, url: 'https://' + url.substr(4).replace(':', '/') }
+  return { displayUrl: url, url }
 }
 
 async function selectStartPathsForRepository (repo, authStatus, sources) {
@@ -415,8 +413,8 @@ function getCurrentBranchName (repo, remote) {
   return (
     remote && repo.noCheckout
       ? git
-        .resolveRef(Object.assign({ ref: 'refs/remotes/' + remote + '/HEAD', depth: 2 }, repo))
-        .catch(() => git.resolveRef(Object.assign({ ref: 'HEAD', depth: 2 }, repo)))
+          .resolveRef(Object.assign({ ref: 'refs/remotes/' + remote + '/HEAD', depth: 2 }, repo))
+          .catch(() => git.resolveRef(Object.assign({ ref: 'HEAD', depth: 2 }, repo)))
       : git.resolveRef(Object.assign({ ref: 'HEAD', depth: 2 }, repo))
   ).then((ref) => (ref.startsWith('refs/') ? ref.replace(SHORTEN_REF_RX, '') : undefined))
 }
@@ -463,7 +461,7 @@ function collectFilesFromStartPath (startPath, repo, authStatus, ref, originUrl,
   return (worktreePath ? readFilesFromWorktree(origin) : readFilesFromGitTree(repo, ref.oid, startPath))
     .then((files) => {
       const batch = deepClone((origin.descriptor = loadComponentDescriptor(files, ref, version)))
-      if ('nav' in batch) batch.nav.origin = origin
+      if ('nav' in batch && Array.isArray(batch.nav)) batch.nav.origin = origin
       batch.files = files.map((file) => assignFileProperties(file, origin))
       batch.origins = [origin]
       return batch
@@ -548,9 +546,9 @@ function readFilesFromGitTree (repo, oid, startPath) {
     Object.assign(root, { dirname: '' })
     return startPath
       ? getGitTreeAtStartPath(repo, oid, startPath).then((start) => {
-        Object.assign(start, { dirname: startPath })
-        return srcGitTree(repo, root, start)
-      })
+          Object.assign(start, { dirname: startPath })
+          return srcGitTree(repo, root, start)
+        })
       : srcGitTree(repo, root)
   })
 }
@@ -605,7 +603,8 @@ function visitGitTree (emitter, repo, root, filter, convert, parent, dirname = '
               (target) => {
                 if (target.type === 'tree') {
                   return visitGitTree(emitter, repo, root, filter, convert, target, vfilePath, target.following)
-                } else if (target.type === 'blob' && filterVerdict === true && (mode = FILE_MODES[target.mode])) {
+                }
+                if (target.type === 'blob' && filterVerdict === true && (mode = FILE_MODES[target.mode])) {
                   return convert(Object.assign({ mode, oid: target.oid, path: vfilePath }, repo)).then((result) =>
                     emitter.emit('entry', result)
                   )
@@ -677,11 +676,11 @@ function readGitObjectAtPath (repo, root, parent, pathSegments, following) {
     if (entry.path === firstPathSegment) {
       return entry.type === 'tree'
         ? git.readTree(Object.assign({ oid: entry.oid }, repo)).then((subtree) => {
-          Object.assign(subtree, { dirname: path.join(parent.dirname, entry.path) })
-          return (pathSegments = pathSegments.slice(1)).length
-            ? readGitObjectAtPath(repo, root, subtree, pathSegments, following)
-            : Object.assign(subtree, { type: 'tree', following }) // Q: should this create copy?
-        })
+            Object.assign(subtree, { dirname: path.join(parent.dirname, entry.path) })
+            return (pathSegments = pathSegments.slice(1)).length
+              ? readGitObjectAtPath(repo, root, subtree, pathSegments, following)
+              : Object.assign(subtree, { type: 'tree', following }) // Q: should this create copy?
+          })
         : entry.mode === SYMLINK_FILE_MODE
           ? readGitSymlink(repo, root, parent, entry, following)
           : Promise.resolve(entry)
@@ -761,7 +760,7 @@ function loadComponentDescriptor (files, ref, version) {
     throw new Error(`version in ${COMPONENT_DESC_FILENAME} cannot have path segments: ${version}`)
   }
   data.version = version
-  return camelCaseKeys(data, ['asciidoc'])
+  return camelCaseKeys(data, ['asciidoc', 'ext'])
 }
 
 function assignFileProperties (file, origin) {
@@ -889,9 +888,8 @@ function identifyAuthStatus (credentialManager, credentials, url) {
   const status = credentialManager.status({ url })
   if (credentials) {
     return typeof status === 'string' && status.startsWith('requested,') ? 'auth-required' : 'auth-embedded'
-  } else if (status != null) {
-    return 'auth-required'
   }
+  if (status != null) return 'auth-required'
 }
 
 /**
@@ -923,9 +921,9 @@ function resolveRemoteUrl (repo, remoteName) {
     if (url) {
       if (url.startsWith('https://') || url.startsWith('http://')) {
         return ~url.indexOf('@') ? url.replace(URL_AUTH_CLEANER_RX, '$1') : url
-      } else if (url.startsWith('git@')) {
-        return 'https://' + url.substr(4).replace(':', '/')
-      } else if (url.startsWith('ssh://')) {
+      }
+      if (url.startsWith('git@')) return 'https://' + url.substr(4).replace(':', '/')
+      if (url.startsWith('ssh://')) {
         return 'https://' + url.substr(url.indexOf('@') + 1 || 6).replace(URL_PORT_CLEANER_RX, '$1')
       }
     }
@@ -958,7 +956,7 @@ function loadGitPlugins (gitConfig, networkConfig, startDir) {
     if (typeof credentialManager.configure === 'function') {
       credentialManager.configure({ config: gitConfig.credentials, startDir })
     }
-    if (typeof credentialManager.status !== 'function') Object.assign(credentialManager, { status () {} })
+    if (typeof credentialManager.status !== 'function') Object.assign(credentialManager, { status: invariably.void })
   } else {
     credentialManager = new GitCredentialManagerStore().configure({ config: gitConfig.credentials, startDir })
   }
@@ -1075,21 +1073,21 @@ function findWorktrees (repo, patterns) {
   return (
     worktreesDir
       ? fsp
-        .readdir(worktreesDir)
-        .then((worktreeNames) => filterRefs(worktreeNames, patterns, patternCache), invariably.emptyArray)
-        .then((worktreeNames) =>
-          Promise.all(
-            worktreeNames.map((worktreeName) => {
-              const gitdir = ospath.resolve(worktreesDir, worktreeName)
-              // NOTE branch name defaults to worktree name if HEAD is detached
-              return getCurrentBranchName(Object.assign({}, repo, { gitdir })).then((branch = worktreeName) =>
-                fsp
-                  .readFile(ospath.join(gitdir, 'gitdir'), 'utf8')
-                  .then((contents) => [branch, { head: ospath.dirname(contents.trimEnd()), name: worktreeName }])
-              )
-            })
+          .readdir(worktreesDir)
+          .then((worktreeNames) => filterRefs(worktreeNames, patterns, patternCache), invariably.emptyArray)
+          .then((worktreeNames) =>
+            Promise.all(
+              worktreeNames.map((worktreeName) => {
+                const gitdir = ospath.resolve(worktreesDir, worktreeName)
+                // NOTE branch name defaults to worktree name if HEAD is detached
+                return getCurrentBranchName(Object.assign({}, repo, { gitdir })).then((branch = worktreeName) =>
+                  fsp
+                    .readFile(ospath.join(gitdir, 'gitdir'), 'utf8')
+                    .then((contents) => [branch, { head: ospath.dirname(contents.trimEnd()), name: worktreeName }])
+                )
+              })
+            )
           )
-        )
       : Promise.resolve()
   ).then((entries = []) => mainWorktree.then((entry) => new Map(entry ? entries.push(entry) && entries : entries)))
 }

package/lib/compute-origin.js

@@ -24,7 +24,7 @@ function computeOrigin (url, authStatus, gitdir, ref, startPath, worktreePath =
   if (authStatus) origin.private = authStatus
   if (url) origin.webUrl = removeGitSuffix(url)
   if (editUrl === true) {
-    const match = url && url.match(HOSTED_GIT_REPO_RX)
+    const match = url?.match(HOSTED_GIT_REPO_RX)
     if (match) {
       const host = match[1]
       let action = 'blob'
@@ -33,8 +33,9 @@ function computeOrigin (url, authStatus, gitdir, ref, startPath, worktreePath =
         category = 'f'
       } else if (host === 'bitbucket.org') {
         action = 'src'
-      } else if (reftype === 'branch') {
-        action = 'edit'
+      } else {
+        if (reftype === 'branch') action = 'edit'
+        if (host.startsWith('gitlab.')) action = '-/' + action
       }
       origin.editUrlPattern = 'https://' + path.join(match[1], match[2], action, refname, category, startPath, '%s')
     }

package/lib/filter-refs.js

@@ -11,10 +11,9 @@ function compileRx (pattern, opts) {
   return Object.defineProperty(rx, 'pattern', { value: pattern })
 }
 
-function createMatcher (patterns, cache, opts) {
+function createMatcher (patterns, cache = Object.assign(new Map(), { braces: new Map() })) {
   const rxs = patterns.map(
-    (pattern) =>
-      cache.get(pattern) || cache.set(pattern, compileRx(pattern, opts || (opts = getMatcherOpts(cache)))).get(pattern)
+    (pattern) => cache.get(pattern) || cache.set(pattern, compileRx(pattern, getMatcherOpts(cache))).get(pattern)
   )
   if (rxs[0].negated) rxs.unshift(MATCH_ALL_RX)
   return (candidate, onMatch) => {
@@ -39,7 +38,7 @@ function createMatcher (patterns, cache, opts) {
   }
 }
 
-function filterRefs (candidates, patterns, cache = Object.assign(new Map(), { braces: new Map() }), onMatch) {
+function filterRefs (candidates, patterns, cache, onMatch) {
   const match = createMatcher(patterns, cache)
   return candidates.reduce((accum, candidate) => {
     if ((candidate = match(candidate, onMatch))) accum.push(candidate)

package/lib/resolve-path-globs.js

@@ -16,11 +16,11 @@ function resolvePathGlobs (base, patterns, listDirents, retrievePath, tree = { p
         if (resolvedPaths.length) {
           const rx = makeMatcherRx(pattern.substr(1), MATCHER_OPTS)
           return resolvedPaths.filter((it) => !rx.test(it))
-        } else {
-          return resolvedPaths
         }
+        return resolvedPaths
       })
-    } else if (RX_MAGIC_DETECTOR.test(pattern)) {
+    }
+    if (RX_MAGIC_DETECTOR.test(pattern)) {
       return glob(base, pattern.split('/'), listDirents, retrievePath, tree).then((nestedPaths) =>
         paths.then((resolvedPaths) => [...resolvedPaths, ...nestedPaths])
       )
@@ -62,35 +62,36 @@ async function glob (base, patternSegments, listDirents, retrievePath, { oid, pa
           dirent.isDirectory() && isMatch(dirent.name)
             ? patternSegments.length
               ? glob(base, patternSegments, listDirents, retrievePath, {
-                oid: dirent.oid,
-                path: joinPath(path, dirent.name),
-                globbed: true,
-              })
+                  oid: dirent.oid,
+                  path: joinPath(path, dirent.name),
+                  globbed: true,
+                })
               : joinPath(path, dirent.name)
             : []
         )
       )
     )
     return explicit ? [...[...explicit].map((it) => joinPath(path, it)), ...discovered] : discovered
-  } else {
-    const [magicBase, nextSegment] = extractMagicBase(patternSegments, patternSegment)
-    patternSegment = magicBase
-    if (nextSegment) {
-      const obj = await retrievePath(base, { oid, path }, patternSegment)
-      if (obj) {
-        return glob(base, patternSegments, listDirents, retrievePath, {
-          oid: obj.oid,
-          path: joinPath(path, patternSegment),
-        })
-      } else if ((patternSegment += '/' + patternSegments.join('/')).indexOf('{')) {
-        return expandBraces(patternSegment).map((it) => joinPath(path, it))
-      }
-      return [joinPath(path, patternSegment)]
-    } else if (globbed) {
-      return (await retrievePath(base, { oid, path }, patternSegment)) ? [joinPath(path, patternSegment)] : []
+  }
+  const [magicBase, nextSegment] = extractMagicBase(patternSegments, patternSegment)
+  patternSegment = magicBase
+  if (nextSegment) {
+    const obj = await retrievePath(base, { oid, path }, patternSegment)
+    if (obj) {
+      return glob(base, patternSegments, listDirents, retrievePath, {
+        oid: obj.oid,
+        path: joinPath(path, patternSegment),
+      })
+    }
+    if ((patternSegment += '/' + patternSegments.join('/')).indexOf('{')) {
+      return expandBraces(patternSegment).map((it) => joinPath(path, it))
     }
     return [joinPath(path, patternSegment)]
   }
+  if (globbed) {
+    return (await retrievePath(base, { oid, path }, patternSegment)) ? [joinPath(path, patternSegment)] : []
+  }
+  return [joinPath(path, patternSegment)]
 }
 
 function extractMagicBase (patternSegments, base) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antora/content-aggregator",
-  "version": "3.2.0-alpha.6",
+  "version": "3.2.0-alpha.8",
   "description": "Fetches and aggregates content from distributed sources for use in an Antora documentation pipeline.",
   "license": "MPL-2.0",
   "author": "OpenDevise Inc. (https://opendevise.com)",
@@ -11,7 +11,11 @@
     "Balachandran Sivakumar <balachandran@balachandran.org>"
   ],
   "homepage": "https://antora.org",
-  "repository": "gitlab:antora/antora",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/antora/antora.git",
+    "directory": "packages/content-aggregator"
+  },
   "bugs": {
     "url": "https://gitlab.com/antora/antora/issues"
   },
@@ -28,9 +32,9 @@
     "#constants": "./lib/constants.js"
   },
   "dependencies": {
-    "@antora/expand-path-helper": "~2.0",
-    "@antora/logger": "3.2.0-alpha.6",
-    "@antora/user-require-helper": "~2.0",
+    "@antora/expand-path-helper": "~3.0",
+    "@antora/logger": "3.2.0-alpha.8",
+    "@antora/user-require-helper": "~3.0",
     "braces": "~3.0",
     "cache-directory": "~2.0",
     "fast-glob": "~3.3",