@netlify/git-utils 4.1.2-rc → 4.1.3-rc

package/lib/commits.js

@@ -0,0 +1,33 @@
+import { git } from './exec.js'
+
+// Return information on each commit since the `base` commit, such as SHA,
+// parent commits, author, committer and commit message
+export const getCommits = function (base, head, cwd) {
+  const stdout = git(['log', `--pretty=${GIT_PRETTY_FORMAT}`, `${base}...${head}`], cwd)
+  const commits = stdout.split('\n').map(getCommit)
+  return commits
+}
+
+// Parse the commit output from a string to a JavaScript object
+const getCommit = function (line) {
+  const [sha, parents, authorName, authorEmail, authorDate, committerName, committerEmail, committerDate, message] =
+    line.split(GIT_PRETTY_SEPARATOR)
+  return {
+    sha,
+    parents,
+    author: { name: authorName, email: authorEmail, date: authorDate },
+    committer: { name: committerName, email: committerEmail, date: committerDate },
+    message,
+  }
+}
+
+// `git log --pretty` does not have any way of separating tokens, except for
+// commits being separated by newlines. Since some tokens (like the commit
+// message or the committer name) might contain a wide range of characters, we
+// need a specific separator.
+// We choose RS (Record separator) which is a rarely used control character
+// intended for this very purpose: separating records. It is used by some
+// formats such as JSON text sequences (RFC 7464).
+const GIT_PRETTY_SEPARATOR = '\u001E'
+// List of commit fields we want to retrieve
+const GIT_PRETTY_FORMAT = ['%H', '%p', '%an', '%ae', '%ai', '%cn', '%ce', '%ci', '%f'].join(GIT_PRETTY_SEPARATOR)

package/lib/diff.js

@@ -0,0 +1,36 @@
+import { git } from './exec.js'
+
+// Return the list of modified|created|deleted files according to git, between
+// the `base` commit and the `HEAD`
+export const getDiffFiles = function (base, head, cwd) {
+  const stdout = git(['diff', '--name-status', '--no-renames', `${base}...${head}`], cwd)
+  const files = stdout.split('\n').map(getDiffFile).filter(Boolean)
+
+  const modifiedFiles = getFilesByType(files, 'M')
+  const createdFiles = getFilesByType(files, 'A')
+  const deletedFiles = getFilesByType(files, 'D')
+  return { modifiedFiles, createdFiles, deletedFiles }
+}
+
+// Parse each `git diff` line
+const getDiffFile = function (line) {
+  const result = DIFF_FILE_REGEXP.exec(line)
+
+  // Happens for example when `base` is invalid
+  if (result === null) {
+    return
+  }
+
+  const [, type, filepath] = result
+  return { type, filepath }
+}
+
+const DIFF_FILE_REGEXP = /([ADM])\s+(.*)/
+
+const getFilesByType = function (files, type) {
+  return files.filter((file) => file.type === type).map(getFilepath)
+}
+
+const getFilepath = function ({ filepath }) {
+  return filepath
+}

package/lib/exec.js

@@ -0,0 +1,44 @@
+import process from 'process'
+
+import { execaSync } from 'execa'
+import moize from 'moize'
+import { pathExistsSync } from 'path-exists'
+
+// Fires the `git` binary. Memoized.
+const mGit = function (args, cwd) {
+  const cwdA = safeGetCwd(cwd)
+  try {
+    const { stdout } = execaSync('git', args, { cwd: cwdA })
+    return stdout
+  } catch (error) {
+    // The child process `error.message` includes stderr and stdout output which most of the times contains duplicate
+    // information. We rely on `error.shortMessage` instead.
+    error.message = error.shortMessage
+    throw error
+  }
+}
+
+// eslint-disable-next-line no-magic-numbers
+export const git = moize(mGit, { isDeepEqual: true, maxSize: 1e3 })
+
+const safeGetCwd = function (cwd) {
+  const cwdA = getCwdValue(cwd)
+
+  if (!pathExistsSync(cwdA)) {
+    throw new Error(`Current directory does not exist: ${cwdA}`)
+  }
+
+  return cwdA
+}
+
+const getCwdValue = function (cwd) {
+  if (cwd !== undefined) {
+    return cwd
+  }
+
+  try {
+    return process.cwd()
+  } catch {
+    throw new Error('Current directory does not exist')
+  }
+}

package/lib/main.js

@@ -0,0 +1,16 @@
+import { getCommits } from './commits.js'
+import { getDiffFiles } from './diff.js'
+import { fileMatch } from './match.js'
+import { getBase, getHead } from './refs.js'
+import { getLinesOfCode } from './stats.js'
+
+// Main entry point to the git utilities
+export const getGitUtils = function ({ base, head, cwd } = {}) {
+  const headA = getHead(cwd, head)
+  const baseA = getBase(base, headA, cwd)
+  const { modifiedFiles, createdFiles, deletedFiles } = getDiffFiles(baseA, headA, cwd)
+  const commits = getCommits(baseA, headA, cwd)
+  const linesOfCode = getLinesOfCode(baseA, headA, cwd)
+  const fileMatchA = fileMatch.bind(null, { modifiedFiles, createdFiles, deletedFiles })
+  return { modifiedFiles, createdFiles, deletedFiles, commits, linesOfCode, fileMatch: fileMatchA }
+}

package/lib/match.js

@@ -0,0 +1,14 @@
+import mapObj from 'map-obj'
+import micromatch from 'micromatch'
+
+// Return functions that return modified|created|deleted files filtered by a
+// globbing pattern
+export const fileMatch = function ({ modifiedFiles, createdFiles, deletedFiles }, ...patterns) {
+  const matchFiles = {
+    modified: modifiedFiles,
+    created: createdFiles,
+    deleted: deletedFiles,
+    edited: [...modifiedFiles, ...createdFiles],
+  }
+  return mapObj(matchFiles, (key, paths) => [key, micromatch(paths, patterns)])
+}

package/lib/refs.js

@@ -0,0 +1,63 @@
+import { env } from 'process'
+
+import { git } from './exec.js'
+
+// Retrieve the `head` commit
+export const getHead = function (cwd, head = 'HEAD') {
+  const result = checkRef(head, cwd)
+  if (result.error !== undefined) {
+    throwError('head', result)
+  }
+  return result.ref
+}
+
+// Retrieve the `base` commit
+export const getBase = function (base, head, cwd) {
+  const refs = getBaseRefs(base, head)
+  const { ref } = findRef(refs, cwd)
+  return ref
+}
+
+const getBaseRefs = function (base, head) {
+  if (base !== undefined) {
+    return [base]
+  }
+
+  if (env.CACHED_COMMIT_REF) {
+    return [env.CACHED_COMMIT_REF]
+  }
+
+  // Some git repositories are missing `master` or `main` branches, so we also try HEAD^.
+  // We end with HEAD as a failsafe.
+  return ['main', 'master', `${head}^`, head]
+}
+
+// Use the first commit that exists
+const findRef = function (refs, cwd) {
+  const results = refs.map((ref) => checkRef(ref, cwd))
+  const result = results.find(refExists)
+  if (result === undefined) {
+    throwError('base', results[0])
+  }
+  return result
+}
+
+// Check if a commit exists
+const checkRef = function (ref, cwd) {
+  try {
+    git(['rev-parse', ref], cwd)
+    return { ref }
+  } catch (error) {
+    return { ref, error }
+  }
+}
+
+const refExists = function ({ error }) {
+  return error === undefined
+}
+
+const throwError = function (name, { ref, error: { message, stderr } }) {
+  const messages = [message, stderr].filter(Boolean).join('\n')
+  const messageA = `Invalid ${name} commit ${ref}\n${messages}`
+  throw new Error(messageA)
+}

package/lib/stats.js

@@ -0,0 +1,23 @@
+import { git } from './exec.js'
+
+// Returns the number of lines of code added, removed or modified since the
+// `base` commit
+export const getLinesOfCode = function (base, head, cwd) {
+  const stdout = git(['diff', '--shortstat', `${base}...${head}`], cwd)
+  const insertions = parseStdout(stdout, INSERTION_REGEXP)
+  const deletions = parseStdout(stdout, DELETION_REGEXP)
+  return insertions + deletions
+}
+
+const parseStdout = function (stdout, regexp) {
+  const result = regexp.exec(stdout)
+
+  if (result === null) {
+    return 0
+  }
+
+  return Number(result[1])
+}
+
+const INSERTION_REGEXP = /(\d+) insertion/
+const DELETION_REGEXP = /(\d+) deletion/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/git-utils",
-  "version": "4.1.2-rc",
+  "version": "4.1.3-rc",
   "description": "Utility for dealing with modified, created, deleted files since a git commit",
   "type": "module",
   "exports": "./lib/main.js",