projen
Version:
CDK for software projects
196 lines • 32.4 kB
JavaScript
;
var _a, _b;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ReleasableCommits = exports.Version = exports.CHANGES_SINCE_LAST_RELEASE = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const path_1 = require("path");
const component_1 = require("./component");
const dependencies_1 = require("./dependencies");
const node_package_1 = require("./javascript/node-package");
/**
* This command determines if there were any changes since the last release in a cross-platform compatible way.
* It is used as a condition for both the `bump` and the `release` tasks.
*
* Explanation:
* - log commits | git log
* - limit log output to a single line per commit | --oneline
* - looks only at the most recent commit | -1
* - silent grep output | grep -q
* - exits with code 0 if a match is found | grep -q "chore(release):"
* - exits with code 1 if a match is found (reverse-match) | grep -qv "chore(release):"
*/
exports.CHANGES_SINCE_LAST_RELEASE = 'git log --oneline -1 | grep -qv "chore(release):"';
/**
* The default package to be used for commit-and-tag-version
*/
const COMMIT_AND_TAG_VERSION_DEFAULT = "commit-and-tag-version@^12";
class Version extends component_1.Component {
constructor(scope, options) {
super(scope);
this.changelogFileName = "changelog.md";
this.versionFileName = "version.txt";
this.releaseTagFileName = "releasetag.txt";
this.bumpPackage = options.bumpPackage ?? COMMIT_AND_TAG_VERSION_DEFAULT;
this.nextVersionCommand = options.nextVersionCommand;
// This component is language independent.
// However, when in the Node.js ecosystem, we can improve the experience by adding a dev dependency on the bump package.
const node = node_package_1.NodePackage.of(this.project);
if (node) {
const { name: bumpName, version: bumpVersion } = dependencies_1.Dependencies.parseDependency(this.bumpPackage);
if (!node.project.deps.isDependencySatisfied(bumpName, dependencies_1.DependencyType.BUILD, bumpVersion ?? "*")) {
node.project.deps.addDependency(this.bumpPackage, dependencies_1.DependencyType.BUILD);
}
}
const versionInputFile = options.versionInputFile;
const changelogFile = path_1.posix.join(options.artifactsDirectory, this.changelogFileName);
const bumpFile = path_1.posix.join(options.artifactsDirectory, this.versionFileName);
const releaseTagFile = path_1.posix.join(options.artifactsDirectory, this.releaseTagFileName);
const commonEnv = {
OUTFILE: versionInputFile,
CHANGELOG: changelogFile,
BUMPFILE: bumpFile,
RELEASETAG: releaseTagFile,
RELEASE_TAG_PREFIX: options.tagPrefix ?? "",
// doesn't work if custom configuration is long
VERSIONRCOPTIONS: JSON.stringify(options.versionrcOptions),
BUMP_PACKAGE: this.bumpPackage,
};
if (options.nextVersionCommand) {
commonEnv.NEXT_VERSION_COMMAND = options.nextVersionCommand;
}
if (options.releasableCommits) {
commonEnv.RELEASABLE_COMMITS = options.releasableCommits.cmd;
}
this.bumpTask = this.project.addTask("bump", {
description: "Bumps version based on latest git tag and generates a changelog entry",
condition: exports.CHANGES_SINCE_LAST_RELEASE,
env: { ...commonEnv },
});
this.bumpTask.builtin("release/bump-version");
this.unbumpTask = this.project.addTask("unbump", {
description: "Restores version to 0.0.0",
env: { ...commonEnv },
});
this.unbumpTask.builtin("release/reset-version");
this.project.addGitIgnore(`/${changelogFile}`);
this.project.addGitIgnore(`/${bumpFile}`);
this.project.addPackageIgnore(`/${changelogFile}`);
this.project.addPackageIgnore(`/${bumpFile}`);
}
/**
* Return the environment variables to modify the bump command for release branches.
*
* These options are used to modify the behavior of the version bumping script
* for additional branches, by setting environment variables.
*
* No settings are inherited from the base `Version` object (but any parameters that
* control versions do conflict with the use of a `nextVersionCommand`).
*/
envForBranch(branchOptions) {
if (this.nextVersionCommand && branchOptions.minMajorVersion) {
throw new Error("minMajorVersion and nextVersionCommand cannot be used together.");
}
const env = {};
if (branchOptions.majorVersion !== undefined) {
env.MAJOR = branchOptions.majorVersion.toString();
}
if (branchOptions.minMajorVersion !== undefined) {
if (branchOptions.majorVersion !== undefined) {
throw new Error(`minMajorVersion and majorVersion cannot be used together.`);
}
env.MIN_MAJOR = branchOptions.minMajorVersion.toString();
}
if (branchOptions.prerelease) {
env.PRERELEASE = branchOptions.prerelease;
}
if (branchOptions.tagPrefix) {
env.RELEASE_TAG_PREFIX = branchOptions.tagPrefix;
}
return env;
}
}
exports.Version = Version;
_a = JSII_RTTI_SYMBOL_1;
Version[_a] = { fqn: "projen.Version", version: "0.95.2" };
/**
* @deprecated use `version.bumpPackage` on the component instance instead
*/
Version.STANDARD_VERSION = COMMIT_AND_TAG_VERSION_DEFAULT;
/**
* Find commits that should be considered releasable to decide if a release is required.
*
* This setting only controls whether a release is triggered, yes or no. The
* paths used here are independent of the code that controls what commits are inspected
* to determine the version number.
*/
class ReleasableCommits {
/**
* Release every commit
*
* This will only not release if the most recent commit is tagged with the latest matching tag.
*
* @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.
* This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `"."`.
*/
static everyCommit(path) {
const cmd = `git log --oneline $LATEST_TAG..HEAD`;
return new ReleasableCommits(withPath(cmd, path));
}
/**
* Limit commits by their conventional commit type
*
* This will only release commit that match one of the provided types.
* Commits are required to follow the conventional commit spec and will be ignored otherwise.
*
* @param types List of conventional commit types that should be released
* @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.
* This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `"."`.
*/
static ofType(types, path) {
const allowedTypes = types.join("|");
// @see: https://github.com/conventional-commits/parser/blob/eeefb961ebf5b9dfea0fea8b06f8ad34a1e439b9/lib/parser.js
// -E requires this to be POSIX Extended Regular Expression, which comes with certain limitations
// see https://en.wikibooks.org/wiki/Regular_Expressions/POSIX-Extended_Regular_Expressions for details
const cmd = `git log --no-merges --oneline $LATEST_TAG..HEAD -E --grep "^(${allowedTypes}){1}(\\([^()[:space:]]+\\))?(!)?:[[:blank:]]+.+"`;
return new ReleasableCommits(withPath(cmd, path));
}
/**
* Release only features and fixes
*
* Shorthand for `ReleasableCommits.onlyOfType(['feat', 'fix'])`.
*
* @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.
* This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `"."`.
*/
static featuresAndFixes(path) {
return ReleasableCommits.ofType(["feat", "fix"], path);
}
/**
* Use an arbitrary shell command to find releasable commits since the latest tag.
*
* A new release will be initiated, if the number of returned commits is greater than zero.
* Must return a newline separate list of commits that should considered releasable.
* `$LATEST_TAG` will be replaced with the actual latest tag for the given prefix.*
*
* @example "git log --oneline $LATEST_TAG..HEAD -- ."
*/
static exec(cmd) {
return new ReleasableCommits(cmd);
}
constructor(cmd) {
this.cmd = cmd;
}
}
exports.ReleasableCommits = ReleasableCommits;
_b = JSII_RTTI_SYMBOL_1;
ReleasableCommits[_b] = { fqn: "projen.ReleasableCommits", version: "0.95.2" };
/**
* Append a path argument to a git command if one is provided
*/
function withPath(cmd, path) {
if (path !== undefined) {
return `${cmd} -- ${path}`;
}
return cmd;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"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","sourcesContent":["import { posix } from \"path\";\nimport { IConstruct } from \"constructs\";\nimport { Component } from \"./component\";\nimport { Dependencies, DependencyType } from \"./dependencies\";\nimport { NodePackage } from \"./javascript/node-package\";\nimport { Task } from \"./task\";\n\n/**\n * This command determines if there were any changes since the last release in a cross-platform compatible way.\n * It is used as a condition for both the `bump` and the `release` tasks.\n *\n * Explanation:\n *  - log commits                                               | git log\n *  - limit log output to a single line per commit              | --oneline\n *  - looks only at the most recent commit                      | -1\n *  - silent grep output                                        | grep -q\n *  - exits with code 0 if a match is found                     | grep -q \"chore(release):\"\n *  - exits with code 1 if a match is found (reverse-match)     | grep -qv \"chore(release):\"\n */\nexport const CHANGES_SINCE_LAST_RELEASE =\n  'git log --oneline -1 | grep -qv \"chore(release):\"';\n\n/**\n * The default package to be used for commit-and-tag-version\n */\nconst COMMIT_AND_TAG_VERSION_DEFAULT = \"commit-and-tag-version@^12\";\n\n/**\n * Options for `Version`.\n */\nexport interface VersionOptions {\n  /**\n   * A name of a .json file to set the `version` field in after a bump.\n   *\n   * @example \"package.json\"\n   */\n  readonly versionInputFile: string;\n\n  /**\n   * The name of the directory into which `changelog.md` and `version.txt` files\n   * are emitted.\n   */\n  readonly artifactsDirectory: string;\n\n  /**\n   * Custom configuration for versionrc file used by standard-release\n   */\n  readonly versionrcOptions?: Record<string, any>;\n\n  /**\n   * The tag prefix corresponding to this version.\n   */\n  readonly tagPrefix?: string;\n\n  /**\n   * Find commits that should be considered releasable\n   * Used to decide if a release is required.\n   *\n   * @default ReleasableCommits.everyCommit()\n   */\n  readonly releasableCommits?: ReleasableCommits;\n\n  /**\n   * The `commit-and-tag-version` compatible package used to bump the package version, as a dependency string.\n   *\n   * This can be any compatible package version, including the deprecated `standard-version@9`.\n   *\n   * @default \"commit-and-tag-version@12\"\n   */\n  readonly bumpPackage?: string;\n\n  /**\n   * A shell command to control the next version to release.\n   *\n   * If present, this shell command will be run before the bump is executed, and\n   * it determines what version to release. It will be executed in the following\n   * environment:\n   *\n   * - Working directory: the project directory.\n   * - `$VERSION`: the current version. Looks like `1.2.3`.\n   * - `$LATEST_TAG`: the most recent tag. Looks like `prefix-v1.2.3`, or may be unset.\n   * - `$SUGGESTED_BUMP`: the suggested bump action based on commits. One of `major|minor|patch|none`.\n   *\n   * The command should print one of the following to `stdout`:\n   *\n   * - Nothing: the next version number will be determined based on commit history.\n   * - `x.y.z`: the next version number will be `x.y.z`.\n   * - `major|minor|patch`: the next version number will be the current version number\n   *   with the indicated component bumped.\n   *\n   * @default - The next version will be determined based on the commit history and project settings.\n   */\n  readonly nextVersionCommand?: string;\n}\n\nexport class Version extends Component {\n  /**\n   * @deprecated use `version.bumpPackage` on the component instance instead\n   */\n  public static readonly STANDARD_VERSION = COMMIT_AND_TAG_VERSION_DEFAULT;\n\n  public readonly bumpTask: Task;\n  public readonly unbumpTask: Task;\n\n  /**\n   * The name of the changelog file (under `artifactsDirectory`).\n   */\n  public readonly changelogFileName: string;\n\n  /**\n   * The name of the file that contains the version (under `artifactsDirectory`).\n   */\n  public readonly versionFileName: string;\n\n  /**\n   * The name of the file that contains the release tag (under `artifactsDirectory`).\n   */\n  public readonly releaseTagFileName: string;\n\n  /**\n   * The package used to bump package versions, as a dependency string.\n   * This is a `commit-and-tag-version` compatible package.\n   */\n  public readonly bumpPackage: string;\n\n  private readonly nextVersionCommand?: string;\n\n  constructor(scope: IConstruct, options: VersionOptions) {\n    super(scope);\n\n    this.changelogFileName = \"changelog.md\";\n    this.versionFileName = \"version.txt\";\n    this.releaseTagFileName = \"releasetag.txt\";\n    this.bumpPackage = options.bumpPackage ?? COMMIT_AND_TAG_VERSION_DEFAULT;\n    this.nextVersionCommand = options.nextVersionCommand;\n\n    // This component is language independent.\n    // However, when in the Node.js ecosystem, we can improve the experience by adding a dev dependency on the bump package.\n    const node = NodePackage.of(this.project);\n    if (node) {\n      const { name: bumpName, version: bumpVersion } =\n        Dependencies.parseDependency(this.bumpPackage);\n      if (\n        !node.project.deps.isDependencySatisfied(\n          bumpName,\n          DependencyType.BUILD,\n          bumpVersion ?? \"*\"\n        )\n      ) {\n        node.project.deps.addDependency(this.bumpPackage, DependencyType.BUILD);\n      }\n    }\n\n    const versionInputFile = options.versionInputFile;\n\n    const changelogFile = posix.join(\n      options.artifactsDirectory,\n      this.changelogFileName\n    );\n    const bumpFile = posix.join(\n      options.artifactsDirectory,\n      this.versionFileName\n    );\n    const releaseTagFile = posix.join(\n      options.artifactsDirectory,\n      this.releaseTagFileName\n    );\n\n    const commonEnv: Record<string, string> = {\n      OUTFILE: versionInputFile,\n      CHANGELOG: changelogFile,\n      BUMPFILE: bumpFile,\n      RELEASETAG: releaseTagFile,\n      RELEASE_TAG_PREFIX: options.tagPrefix ?? \"\",\n      // doesn't work if custom configuration is long\n      VERSIONRCOPTIONS: JSON.stringify(options.versionrcOptions),\n      BUMP_PACKAGE: this.bumpPackage,\n    };\n    if (options.nextVersionCommand) {\n      commonEnv.NEXT_VERSION_COMMAND = options.nextVersionCommand;\n    }\n    if (options.releasableCommits) {\n      commonEnv.RELEASABLE_COMMITS = options.releasableCommits.cmd;\n    }\n\n    this.bumpTask = this.project.addTask(\"bump\", {\n      description:\n        \"Bumps version based on latest git tag and generates a changelog entry\",\n      condition: CHANGES_SINCE_LAST_RELEASE,\n      env: { ...commonEnv },\n    });\n\n    this.bumpTask.builtin(\"release/bump-version\");\n\n    this.unbumpTask = this.project.addTask(\"unbump\", {\n      description: \"Restores version to 0.0.0\",\n      env: { ...commonEnv },\n    });\n\n    this.unbumpTask.builtin(\"release/reset-version\");\n\n    this.project.addGitIgnore(`/${changelogFile}`);\n    this.project.addGitIgnore(`/${bumpFile}`);\n    this.project.addPackageIgnore(`/${changelogFile}`);\n    this.project.addPackageIgnore(`/${bumpFile}`);\n  }\n\n  /**\n   * Return the environment variables to modify the bump command for release branches.\n   *\n   * These options are used to modify the behavior of the version bumping script\n   * for additional branches, by setting environment variables.\n   *\n   * No settings are inherited from the base `Version` object (but any parameters that\n   * control versions do conflict with the use of a `nextVersionCommand`).\n   */\n  public envForBranch(\n    branchOptions: VersionBranchOptions\n  ): Record<string, string> {\n    if (this.nextVersionCommand && branchOptions.minMajorVersion) {\n      throw new Error(\n        \"minMajorVersion and nextVersionCommand cannot be used together.\"\n      );\n    }\n\n    const env: Record<string, string> = {};\n    if (branchOptions.majorVersion !== undefined) {\n      env.MAJOR = branchOptions.majorVersion.toString();\n    }\n\n    if (branchOptions.minMajorVersion !== undefined) {\n      if (branchOptions.majorVersion !== undefined) {\n        throw new Error(\n          `minMajorVersion and majorVersion cannot be used together.`\n        );\n      }\n\n      env.MIN_MAJOR = branchOptions.minMajorVersion.toString();\n    }\n\n    if (branchOptions.prerelease) {\n      env.PRERELEASE = branchOptions.prerelease;\n    }\n\n    if (branchOptions.tagPrefix) {\n      env.RELEASE_TAG_PREFIX = branchOptions.tagPrefix;\n    }\n\n    return env;\n  }\n}\n\n/**\n * Options to pass to `modifyBranchEnvironment`\n */\nexport interface VersionBranchOptions {\n  /**\n   * The major versions released from this branch.\n   */\n  readonly majorVersion?: number;\n\n  /**\n   * The minimum major version to release.\n   */\n  readonly minMajorVersion?: number;\n\n  /**\n   * The minor versions released from this branch.\n   */\n  readonly minorVersion?: number;\n\n  /**\n   * Bump the version as a pre-release tag.\n   *\n   * @default - normal releases\n   */\n  readonly prerelease?: string;\n\n  /**\n   * Automatically add the given prefix to release tags.\n   * Useful if you are releasing on multiple branches with overlapping\n   * version numbers.\n   *\n   * Note: this prefix is used to detect the latest tagged version\n   * when bumping, so if you change this on a project with an existing version\n   * history, you may need to manually tag your latest release\n   * with the new prefix.\n   *\n   * @default - no prefix\n   */\n  readonly tagPrefix?: string;\n}\n\n/**\n * Find commits that should be considered releasable to decide if a release is required.\n *\n * This setting only controls whether a release is triggered, yes or no. The\n * paths used here are independent of the code that controls what commits are inspected\n * to determine the version number.\n */\nexport class ReleasableCommits {\n  /**\n   * Release every commit\n   *\n   * This will only not release if the most recent commit is tagged with the latest matching tag.\n   *\n   * @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.\n   * This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `\".\"`.\n   */\n  static everyCommit(path?: string) {\n    const cmd = `git log --oneline $LATEST_TAG..HEAD`;\n    return new ReleasableCommits(withPath(cmd, path));\n  }\n\n  /**\n   * Limit commits by their conventional commit type\n   *\n   * This will only release commit that match one of the provided types.\n   * Commits are required to follow the conventional commit spec and will be ignored otherwise.\n   *\n   * @param types List of conventional commit types that should be released\n   * @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.\n   * This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `\".\"`.\n   */\n  static ofType(types: string[], path?: string) {\n    const allowedTypes = types.join(\"|\");\n\n    // @see: https://github.com/conventional-commits/parser/blob/eeefb961ebf5b9dfea0fea8b06f8ad34a1e439b9/lib/parser.js\n    // -E requires this to be POSIX Extended Regular Expression, which comes with certain limitations\n    // see https://en.wikibooks.org/wiki/Regular_Expressions/POSIX-Extended_Regular_Expressions for details\n    const cmd = `git log --no-merges --oneline $LATEST_TAG..HEAD -E --grep \"^(${allowedTypes}){1}(\\\\([^()[:space:]]+\\\\))?(!)?:[[:blank:]]+.+\"`;\n\n    return new ReleasableCommits(withPath(cmd, path));\n  }\n\n  /**\n   * Release only features and fixes\n   *\n   * Shorthand for `ReleasableCommits.onlyOfType(['feat', 'fix'])`.\n   *\n   * @param path Consider only commits that are enough to explain how the files that match the specified paths came to be.\n   * This path is relative to the current working dir of the `bump` task, i.e. to only consider commits of a subproject use `\".\"`.\n   */\n  static featuresAndFixes(path?: string) {\n    return ReleasableCommits.ofType([\"feat\", \"fix\"], path);\n  }\n\n  /**\n   * Use an arbitrary shell command to find releasable commits since the latest tag.\n   *\n   * A new release will be initiated, if the number of returned commits is greater than zero.\n   * Must return a newline separate list of commits that should considered releasable.\n   * `$LATEST_TAG` will be replaced with the actual latest tag for the given prefix.*\n   *\n   * @example \"git log --oneline $LATEST_TAG..HEAD -- .\"\n   */\n  static exec(cmd: string) {\n    return new ReleasableCommits(cmd);\n  }\n\n  private constructor(public cmd: string) {}\n}\n\n/**\n * Append a path argument to a git command if one is provided\n */\nfunction withPath(cmd: string, path?: string): string {\n  if (path !== undefined) {\n    return `${cmd} -- ${path}`;\n  }\n\n  return cmd;\n}\n"]}