@netlify/git-utils 2.0.2

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2020 Netlify <team@netlify.com>
+Portions Copyright (c) 2016-2019 Orta Therox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+[![Coverage Status](https://codecov.io/gh/netlify/build/branch/main/graph/badge.svg)](https://codecov.io/gh/netlify/build)
+[![Build](https://github.com/netlify/build/workflows/Build/badge.svg)](https://github.com/netlify/build/actions)
+
+# Git Utility
+
+Utility for dealing with modified, created, deleted files since a git commit.
+
+## Usage
+
+```js
+/* Export the Netlify Plugin */
+module.exports = {
+  onPreBuild: ({ utils }) => {
+    const { git } = utils
+
+    /* Do stuff if files modified */
+    if (git.modifiedFiles.length !== 0) {
+      console.log('Modified files:', git.modifiedFiles)
+    }
+
+    /* Do stuff only if html code edited */
+    const htmlFiles = git.fileMatch('**/*.html')
+    console.log('html files git info:', htmlFiles)
+
+    if (htmlFiles.edited.length !== 0) {
+      console.log('>> Run thing because HTML has changed\n')
+    }
+    //
+    /* Do stuff only if markdown files edited */
+    const markdownFiles = git.fileMatch('**/*.md')
+    console.log('markdown files git info:', markdownFiles)
+
+    if (markdownFiles.modified.length !== 0) {
+      console.log('>> Run thing because Markdown files have been created/changed/deleted\n')
+    }
+
+    /* Do stuff only if css files edited */
+    const cssFiles = git.fileMatch('**/*.css')
+    if (cssFiles.deleted.length !== 0) {
+      console.log('>> Run thing because css files have been deleted\n')
+      console.log(cssFiles)
+    }
+  },
+}
+```
+
+## API
+
+The `git` util includes the following signature.
+
+```js
+module.exports = {
+  onPreBuild: ({ utils }) => {
+    console.log(utils.git)
+    // {
+    // fileMatch: [Function], <-- Lookup function. See below
+    // modifiedFiles: [ Array of all modified files ],
+    // createdFiles: [ Array of all created files ],
+    // deletedFiles: [ Array of all deleted files ],
+    // commits: [ Array of commits with details ],
+    // linesOfCode: [AsyncFunction: linesOfCode] <-- how many lines of code have changed
+    // }
+    //
+  },
+}
+```
+
+`git.fileMatch()` is a glob matcher function to detect the git status of a pattern of files.
+
+Example:
+
+```js
+const cssFiles = git.fileMatch('**/*.css')
+console.log('cssFiles', cssFiles)
+// {
+// modified: [ 'just-changed.css', 'just-changed-two.css' ],
+// created: [ 'just-added.css' ],
+// deleted: [ 'just-deleted.css' ],
+// edited: [ 'just-changed.css', 'just-changed-two.css', 'just-added.css', 'just-deleted.css' ]
+// }
+//
+```
+
+## Prior art
+
+This was originally found in [danger.js](https://danger.systems/js/) and extracted into this utility

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@netlify/git-utils",
+  "version": "2.0.2",
+  "description": "Utility for dealing with modified, created, deleted files since a git commit",
+  "main": "src/main.js",
+  "files": [
+    "src/**/*.js"
+  ],
+  "author": "Netlify Inc.",
+  "scripts": {
+    "prepublishOnly": "cd ../../ && npm run prepublishOnly"
+  },
+  "keywords": [
+    "nodejs",
+    "javascript",
+    "windows",
+    "macos",
+    "linux",
+    "shell",
+    "bash",
+    "build",
+    "terminal",
+    "deployment",
+    "es6",
+    "serverless",
+    "continuous-integration",
+    "continuous-delivery",
+    "ci",
+    "continuous-deployment",
+    "plugins",
+    "continuous-testing",
+    "netlify-plugin",
+    "netlify"
+  ],
+  "homepage": "https://github.com/netlify/build",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/netlify/build.git",
+    "directory": "packages/git-utils"
+  },
+  "bugs": {
+    "url": "https://github.com/netlify/build/issues"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "execa": "^5.1.1",
+    "map-obj": "^4.0.0",
+    "micromatch": "^4.0.2",
+    "moize": "^6.0.0",
+    "path-exists": "^4.0.0"
+  },
+  "devDependencies": {
+    "ava": "^3.15.0"
+  },
+  "engines": {
+    "node": ">=10.18.0"
+  }
+}

package/src/commits.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { git } = require('./exec')
+
+// Return information on each commit since the `base` commit, such as SHA,
+// parent commits, author, committer and commit message
+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)
+
+module.exports = { getCommits }

package/src/diff.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { git } = require('./exec')
+
+// Return the list of modified|created|deleted files according to git, between
+// the `base` commit and the `HEAD`
+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
+}
+
+module.exports = { getDiffFiles }

package/src/exec.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const process = require('process')
+
+const execa = require('execa')
+const moize = require('moize')
+const pathExists = require('path-exists')
+
+// Fires the `git` binary. Memoized.
+const mGit = function (args, cwd) {
+  const cwdA = safeGetCwd(cwd)
+  try {
+    const { stdout } = execa.sync('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
+const git = moize(mGit, { isDeepEqual: true, maxSize: 1e3 })
+
+const safeGetCwd = function (cwd) {
+  const cwdA = getCwdValue(cwd)
+
+  if (!pathExists.sync(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 (error) {
+    throw new Error('Current directory does not exist')
+  }
+}
+
+module.exports = { git }

package/src/main.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { getCommits } = require('./commits')
+const { getDiffFiles } = require('./diff')
+const { fileMatch } = require('./match')
+const { getBase, getHead } = require('./refs')
+const { getLinesOfCode } = require('./stats')
+
+// Main entry point to the git utilities
+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 }
+}
+
+module.exports = getGitUtils

package/src/match.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const mapObj = require('map-obj')
+const micromatch = require('micromatch')
+
+// Return functions that return modified|created|deleted files filtered by a
+// globbing pattern
+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)])
+}
+
+module.exports = { fileMatch }

package/src/refs.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const { env } = require('process')
+
+const { git } = require('./exec')
+
+// Retrieve the `head` commit
+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
+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)
+}
+
+module.exports = { getBase, getHead }

package/src/stats.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { git } = require('./exec')
+
+// Returns the number of lines of code added, removed or modified since the
+// `base` commit
+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/
+
+module.exports = { getLinesOfCode }