@jjrawlins/cdk-git-tagger 0.0.0

package/node_modules/mock-fs/lib/item.js

@@ -0,0 +1,338 @@
+'use strict';
+
+const fsBinding = process.binding('fs');
+const statsConstructor = fsBinding.statValues
+  ? fsBinding.statValues.constructor
+  : Float64Array;
+// Nodejs v18.7.0 changed bigint stats type from BigUint64Array to BigInt64Array
+// https://github.com/nodejs/node/pull/43714
+const bigintStatsConstructor = fsBinding.bigintStatValues
+  ? fsBinding.bigintStatValues.constructor
+  : BigUint64Array;
+
+let counter = 0;
+
+/**
+ * Permissions.
+ * @enum {number}
+ */
+const permissions = {
+  USER_READ: 256, // 0400
+  USER_WRITE: 128, // 0200
+  USER_EXEC: 64, // 0100
+  GROUP_READ: 32, // 0040
+  GROUP_WRITE: 16, // 0020
+  GROUP_EXEC: 8, // 0010
+  OTHER_READ: 4, // 0004
+  OTHER_WRITE: 2, // 0002
+  OTHER_EXEC: 1, // 0001
+};
+
+function getUid() {
+  // force 0 on windows.
+  return process.getuid ? process.getuid() : 0;
+}
+
+function getGid() {
+  // force 0 on windows.
+  return process.getgid ? process.getgid() : 0;
+}
+
+/**
+ * A filesystem item.
+ * @class
+ */
+function Item() {
+  const now = Date.now();
+
+  /**
+   * Access time.
+   * @type {Date}
+   */
+  this._atime = new Date(now);
+
+  /**
+   * Change time.
+   * @type {Date}
+   */
+  this._ctime = new Date(now);
+
+  /**
+   * Birth time.
+   * @type {Date}
+   */
+  this._birthtime = new Date(now);
+
+  /**
+   * Modification time.
+   * @type {Date}
+   */
+  this._mtime = new Date(now);
+
+  /**
+   * Permissions.
+   */
+  this._mode = 438; // 0666
+
+  /**
+   * User id.
+   * @type {number}
+   */
+  this._uid = getUid();
+
+  /**
+   * Group id.
+   * @type {number}
+   */
+  this._gid = getGid();
+
+  /**
+   * Item number.
+   * @type {number}
+   */
+  this._id = ++counter;
+
+  /**
+   * Number of links to this item.
+   */
+  this.links = 0;
+}
+
+/**
+ * Add execute if read allowed
+ * See notes in index.js -> mapping#addDir
+ * @param {number} mode The file mode.
+ * @return {number} The modified mode.
+ */
+Item.fixWin32Permissions = (mode) =>
+  process.platform !== 'win32'
+    ? mode
+    : mode |
+      (mode & permissions.USER_READ && permissions.USER_EXEC) |
+      (mode & permissions.GROUP_READ && permissions.GROUP_EXEC) |
+      (mode & permissions.OTHER_READ && permissions.OTHER_EXEC);
+
+/**
+ * Determine if the current user has read permission.
+ * @return {boolean} The current user can read.
+ */
+Item.prototype.canRead = function () {
+  const uid = getUid();
+  const gid = getGid();
+  let can = false;
+  if (process.getuid && uid === 0) {
+    can = true;
+  } else if (uid === this._uid) {
+    can = (permissions.USER_READ & this._mode) === permissions.USER_READ;
+  } else if (gid === this._gid) {
+    can = (permissions.GROUP_READ & this._mode) === permissions.GROUP_READ;
+  } else {
+    can = (permissions.OTHER_READ & this._mode) === permissions.OTHER_READ;
+  }
+  return can;
+};
+
+/**
+ * Determine if the current user has write permission.
+ * @return {boolean} The current user can write.
+ */
+Item.prototype.canWrite = function () {
+  const uid = getUid();
+  const gid = getGid();
+  let can = false;
+  if (process.getuid && uid === 0) {
+    can = true;
+  } else if (uid === this._uid) {
+    can = (permissions.USER_WRITE & this._mode) === permissions.USER_WRITE;
+  } else if (gid === this._gid) {
+    can = (permissions.GROUP_WRITE & this._mode) === permissions.GROUP_WRITE;
+  } else {
+    can = (permissions.OTHER_WRITE & this._mode) === permissions.OTHER_WRITE;
+  }
+  return can;
+};
+
+/**
+ * Determine if the current user has execute permission.
+ * @return {boolean} The current user can execute.
+ */
+Item.prototype.canExecute = function () {
+  const uid = getUid();
+  const gid = getGid();
+  let can = false;
+  if (process.getuid && uid === 0) {
+    can = true;
+  } else if (uid === this._uid) {
+    can = (permissions.USER_EXEC & this._mode) === permissions.USER_EXEC;
+  } else if (gid === this._gid) {
+    can = (permissions.GROUP_EXEC & this._mode) === permissions.GROUP_EXEC;
+  } else {
+    can = (permissions.OTHER_EXEC & this._mode) === permissions.OTHER_EXEC;
+  }
+  return can;
+};
+
+/**
+ * Get access time.
+ * @return {Date} Access time.
+ */
+Item.prototype.getATime = function () {
+  return this._atime;
+};
+
+/**
+ * Set access time.
+ * @param {Date} atime Access time.
+ */
+Item.prototype.setATime = function (atime) {
+  this._atime = atime;
+};
+
+/**
+ * Get change time.
+ * @return {Date} Change time.
+ */
+Item.prototype.getCTime = function () {
+  return this._ctime;
+};
+
+/**
+ * Set change time.
+ * @param {Date} ctime Change time.
+ */
+Item.prototype.setCTime = function (ctime) {
+  this._ctime = ctime;
+};
+
+/**
+ * Get birth time.
+ * @return {Date} Birth time.
+ */
+Item.prototype.getBirthtime = function () {
+  return this._birthtime;
+};
+
+/**
+ * Set change time.
+ * @param {Date} birthtime Birth time.
+ */
+Item.prototype.setBirthtime = function (birthtime) {
+  this._birthtime = birthtime;
+};
+
+/**
+ * Get modification time.
+ * @return {Date} Modification time.
+ */
+Item.prototype.getMTime = function () {
+  return this._mtime;
+};
+
+/**
+ * Set modification time.
+ * @param {Date} mtime Modification time.
+ */
+Item.prototype.setMTime = function (mtime) {
+  this._mtime = mtime;
+};
+
+/**
+ * Get mode (permission only, e.g 0666).
+ * @return {number} Mode.
+ */
+Item.prototype.getMode = function () {
+  return this._mode;
+};
+
+/**
+ * Set mode (permission only, e.g 0666).
+ * @param {Date} mode Mode.
+ */
+Item.prototype.setMode = function (mode) {
+  this.setCTime(new Date());
+  this._mode = mode;
+};
+
+/**
+ * Get user id.
+ * @return {number} User id.
+ */
+Item.prototype.getUid = function () {
+  return this._uid;
+};
+
+/**
+ * Set user id.
+ * @param {number} uid User id.
+ */
+Item.prototype.setUid = function (uid) {
+  this.setCTime(new Date());
+  this._uid = uid;
+};
+
+/**
+ * Get group id.
+ * @return {number} Group id.
+ */
+Item.prototype.getGid = function () {
+  return this._gid;
+};
+
+/**
+ * Set group id.
+ * @param {number} gid Group id.
+ */
+Item.prototype.setGid = function (gid) {
+  this.setCTime(new Date());
+  this._gid = gid;
+};
+
+/**
+ * Get item stats.
+ * @param {boolean} bigint Use BigInt.
+ * @return {object} Stats properties.
+ */
+Item.prototype.getStats = function (bigint) {
+  const stats = bigint
+    ? new bigintStatsConstructor(36)
+    : new statsConstructor(36);
+  const convert = bigint ? (v) => BigInt(v) : (v) => v;
+
+  stats[0] = convert(8675309); // dev
+  // [1] is mode
+  stats[2] = convert(this.links); // nlink
+  stats[3] = convert(this.getUid()); // uid
+  stats[4] = convert(this.getGid()); // gid
+  stats[5] = convert(0); // rdev
+  stats[6] = convert(4096); // blksize
+  stats[7] = convert(this._id); // ino
+  // [8] is size
+  // [9] is blocks
+  const atimeMs = +this.getATime();
+  stats[10] = convert(Math.floor(atimeMs / 1000)); // atime seconds
+  stats[11] = convert((atimeMs % 1000) * 1000000); // atime nanoseconds
+  const mtimeMs = +this.getMTime();
+  stats[12] = convert(Math.floor(mtimeMs / 1000)); // atime seconds
+  stats[13] = convert((mtimeMs % 1000) * 1000000); // atime nanoseconds
+  const ctimeMs = +this.getCTime();
+  stats[14] = convert(Math.floor(ctimeMs / 1000)); // atime seconds
+  stats[15] = convert((ctimeMs % 1000) * 1000000); // atime nanoseconds
+  const birthtimeMs = +this.getBirthtime();
+  stats[16] = convert(Math.floor(birthtimeMs / 1000)); // atime seconds
+  stats[17] = convert((birthtimeMs % 1000) * 1000000); // atime nanoseconds
+  return stats;
+};
+
+/**
+ * Get the item's string representation.
+ * @return {string} String representation.
+ */
+Item.prototype.toString = function () {
+  return '[' + this.constructor.name + ']';
+};
+
+/**
+ * Export the constructor.
+ * @type {function()}
+ */
+module.exports = Item;

package/node_modules/mock-fs/lib/loader.js

@@ -0,0 +1,121 @@
+const {fixWin32Permissions} = require('./item.js');
+const path = require('path');
+const FileSystem = require('./filesystem.js');
+const fs = require('fs');
+const bypass = require('./bypass.js');
+
+const createContext = ({output, options = {}, target}, newContext) =>
+  Object.assign(
+    {
+      // Assign options and set defaults if needed
+      options: {
+        recursive: options.recursive !== false,
+        lazy: options.lazy !== false,
+      },
+      output,
+      target,
+    },
+    newContext
+  );
+
+function addFile(context, stats, isRoot) {
+  const {output, target} = context;
+  const {lazy} = context.options;
+
+  if (!stats.isFile()) {
+    throw new Error(`${target} is not a valid file!`);
+  }
+
+  const outputPropKey = isRoot ? target : path.basename(target);
+
+  output[outputPropKey] = () => {
+    const content = !lazy ? fs.readFileSync(target) : '';
+    const file = FileSystem.file(Object.assign({}, stats, {content}))();
+
+    if (lazy) {
+      Object.defineProperty(file, '_content', {
+        get() {
+          const res = bypass(() => fs.readFileSync(target));
+          Object.defineProperty(file, '_content', {
+            value: res,
+            writable: true,
+          });
+          return res;
+        },
+        set(data) {
+          Object.defineProperty(file, '_content', {
+            value: data,
+            writable: true,
+          });
+        },
+        configurable: true,
+      });
+    }
+
+    return file;
+  };
+
+  return output[outputPropKey];
+}
+
+function addDir(context, stats, isRoot) {
+  const {target, output} = context;
+  const {recursive} = context.options;
+
+  if (!stats.isDirectory()) {
+    throw new Error(`${target} is not a valid directory!`);
+  }
+
+  stats = Object.assign({}, stats);
+  const outputPropKey = isRoot ? target : path.basename(target);
+
+  // On windows platforms, directories do not have the executable flag, which causes FileSystem.prototype.getItem
+  // to think that the directory cannot be traversed. This is a workaround, however, a better solution may be to
+  // re-think the logic in FileSystem.prototype.getItem
+  // This workaround adds executable privileges if read privileges are found
+  stats.mode = fixWin32Permissions(stats.mode);
+
+  // Create directory factory
+  const directoryItems = {};
+  output[outputPropKey] = FileSystem.directory(
+    Object.assign(stats, {items: directoryItems})
+  );
+
+  fs.readdirSync(target).forEach((p) => {
+    const absPath = path.join(target, p);
+    const stats = fs.statSync(absPath);
+    const newContext = createContext(context, {
+      target: absPath,
+      output: directoryItems,
+    });
+
+    if (recursive && stats.isDirectory()) {
+      addDir(newContext, stats);
+    } else if (stats.isFile()) {
+      addFile(newContext, stats);
+    }
+  });
+
+  return output[outputPropKey];
+}
+
+/**
+ * Load directory or file from real FS
+ * @param {string} p The path.
+ * @param {object} options The options.
+ * @return {*} The return.
+ */
+exports.load = function (p, options) {
+  return bypass(() => {
+    p = path.resolve(p);
+
+    const stats = fs.statSync(p);
+    const context = createContext({output: {}, options, target: p});
+
+    if (stats.isDirectory()) {
+      return addDir(context, stats, true);
+    } else if (stats.isFile()) {
+      return addFile(context, stats, true);
+    }
+  });
+};

package/node_modules/mock-fs/lib/readfilecontext.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const {AbortError} = require('./error.js');
+const {FSReqCallback} = process.binding('fs');
+
+/**
+ * This is a workaround for getting access to the ReadFileContext
+ * prototype, which we need to be able to patch its methods.
+ * @return {object} The prototype.
+ */
+exports.getReadFileContextPrototype = function () {
+  const fs = require('fs');
+  const fsBinding = process.binding('fs');
+
+  const originalOpen = fsBinding.open;
+
+  let proto;
+  fsBinding.open = (_path, _flags, _mode, req) => {
+    proto = Object.getPrototypeOf(req.context);
+    return originalOpen.apply(fsBinding, [_path, _flags, _mode, req]);
+  };
+
+  fs.readFile('/ignored.txt', () => {});
+
+  fsBinding.open = originalOpen;
+
+  return proto;
+};
+
+/**
+ * This patches the ReadFileContext prototype to use mocked bindings
+ * when available. This entire implementation is more or less fully
+ * copied over from Node.js's /lib/internal/fs/read_file_context.js
+ *
+ * This patch is required to support Node.js v16+, where the ReadFileContext
+ * closes directly over the internal fs bindings, and is also eagerly loader.
+ *
+ * See https://github.com/tschaub/mock-fs/issues/332 for more information.
+ *
+ * @param {object} prototype The ReadFileContext prototype object to patch.
+ */
+exports.patchReadFileContext = function (prototype) {
+  const origRead = prototype.read;
+  const origClose = prototype.close;
+
+  const kReadFileUnknownBufferLength = 64 * 1024;
+  const kReadFileBufferLength = 512 * 1024;
+
+  function readFileAfterRead(err, bytesRead) {
+    const context = this.context;
+
+    if (err) {
+      return context.close(err);
+    }
+    context.pos += bytesRead;
+
+    if (context.pos === context.size || bytesRead === 0) {
+      context.close();
+    } else {
+      if (context.size === 0) {
+        // Unknown size, just read until we don't get bytes.
+        const buffer =
+          bytesRead === kReadFileUnknownBufferLength
+            ? context.buffer
+            : context.buffer.slice(0, bytesRead);
+        context.buffers.push(buffer);
+      }
+      context.read();
+    }
+  }
+
+  function readFileAfterClose(err) {
+    const context = this.context;
+    const callback = context.callback;
+    let buffer = null;
+
+    if (context.err || err) {
+      // This is a simplification from Node.js, where we don't bother merging the errors
+      return callback(context.err || err);
+    }
+
+    try {
+      if (context.size === 0) {
+        buffer = Buffer.concat(context.buffers, context.pos);
+      } else if (context.pos < context.size) {
+        buffer = context.buffer.slice(0, context.pos);
+      } else {
+        buffer = context.buffer;
+      }
+
+      if (context.encoding) {
+        buffer = buffer.toString(context.encoding);
+      }
+    } catch (err) {
+      return callback(err);
+    }
+
+    callback(null, buffer);
+  }
+
+  prototype.read = function read() {
+    if (!prototype._mockedBinding) {
+      return origRead.apply(this, arguments);
+    }
+
+    let buffer;
+    let offset;
+    let length;
+
+    if (this.signal && this.signal.aborted) {
+      return this.close(new AbortError());
+    }
+    if (this.size === 0) {
+      buffer = Buffer.allocUnsafeSlow(kReadFileUnknownBufferLength);
+      offset = 0;
+      length = kReadFileUnknownBufferLength;
+      this.buffer = buffer;
+    } else {
+      buffer = this.buffer;
+      offset = this.pos;
+      length = Math.min(kReadFileBufferLength, this.size - this.pos);
+    }
+
+    const req = new FSReqCallback();
+    req.oncomplete = readFileAfterRead;
+    req.context = this;
+
+    // This call and the one in close() is what we want to change, the
+    // rest is pretty much the same as Node.js except we don't have access
+    // to some of the internal optimizations.
+    prototype._mockedBinding.read(this.fd, buffer, offset, length, -1, req);
+  };
+
+  prototype.close = function close(err) {
+    if (!prototype._mockedBinding) {
+      return origClose.apply(this, arguments);
+    }
+
+    if (this.isUserFd) {
+      process.nextTick(function tick(context) {
+        readFileAfterClose.apply({context}, [null]);
+      }, this);
+      return;
+    }
+
+    const req = new FSReqCallback();
+    req.oncomplete = readFileAfterClose;
+    req.context = this;
+    this.err = err;
+
+    prototype._mockedBinding.close(this.fd, req);
+  };
+};

package/node_modules/mock-fs/lib/symlink.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const util = require('util');
+const Item = require('./item.js');
+const constants = require('constants');
+
+/**
+ * A directory.
+ * @class
+ */
+function SymbolicLink() {
+  Item.call(this);
+
+  /**
+   * Relative path to source.
+   * @type {string}
+   */
+  this._path = undefined;
+}
+util.inherits(SymbolicLink, Item);
+
+/**
+ * Set the path to the source.
+ * @param {string} pathname Path to source.
+ */
+SymbolicLink.prototype.setPath = function (pathname) {
+  this._path = pathname;
+};
+
+/**
+ * Get the path to the source.
+ * @return {string} Path to source.
+ */
+SymbolicLink.prototype.getPath = function () {
+  return this._path;
+};
+
+/**
+ * Get symbolic link stats.
+ * @param {boolean} bigint Use BigInt.
+ * @return {object} Stats properties.
+ */
+SymbolicLink.prototype.getStats = function (bigint) {
+  const size = this._path.length;
+  const stats = Item.prototype.getStats.call(this, bigint);
+  const convert = bigint ? (v) => BigInt(v) : (v) => v;
+
+  stats[1] = convert(this.getMode() | constants.S_IFLNK); // mode
+  stats[8] = convert(size); // size
+  stats[9] = convert(Math.ceil(size / 512)); // blocks
+
+  return stats;
+};
+
+/**
+ * Export the constructor.
+ * @type {function()}
+ */
+module.exports = SymbolicLink;

package/node_modules/mock-fs/license.md

@@ -0,0 +1,49 @@
+# License for mock-fs
+
+The mock-fs module is distributed under the MIT license.  Find the full source
+here: http://tschaub.mit-license.org/
+
+Copyright Tim Schaub.
+
+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.
+
+
+# Node's license
+
+This module includes parts of the Node library itself (specifically, the fs
+module is included from several different versions of Node).  Find Node's
+license below:
+
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+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.