feat: revert update action runtime to node 16

* fix: prefer getMultilineInput and getBooleanInput from actions/core

* build: update distribution

* feat: update action runtime to node 16

* ci: update setup-node and cache npm dependencies

* revert: getMultilineInput to getInputAsArray

* build: update distribution

.eslintignore

@@ -0,0 +1,3 @@
+dist/
+lib/
+node_modules/

.eslintrc.json

@@ -0,0 +1,23 @@
+{
+  "env": { "node": true, "jest": true },
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": { "ecmaVersion": 9, "sourceType": "module" },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:import/errors",
+    "plugin:import/warnings",
+    "plugin:import/typescript",
+    "plugin:prettier/recommended"
+  ],
+  "plugins": ["@typescript-eslint"],
+  "rules": {
+    "@typescript-eslint/camelcase": "off"
+  },
+  "settings": {
+    "import/resolver": {
+      "typescript": {}
+    }
+  }
+}

.github/CODEOWNERS

@@ -1 +0,0 @@
-* @peter-evans

.github/workflows/ci.yml

@@ -0,0 +1,131 @@
+name: CI
+on:
+  push:
+    branches: [main]
+    paths-ignore:
+      - 'README.md'
+      - 'docs/**'
+  pull_request:
+    branches: [main]
+    paths-ignore:
+      - 'README.md'
+      - 'docs/**'
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12.x
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.x'
+      - run: npm ci
+      - run: npm run build
+      - run: npm run format-check
+      - run: npm run lint
+      - run: npm run test
+      - uses: actions/upload-artifact@v2
+        with:
+          name: dist
+          path: dist
+      - uses: actions/upload-artifact@v2
+        with:
+          name: action.yml
+          path: action.yml
+
+  test:
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository
+    needs: [build]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [built, committed]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: main
+      - if: matrix.target == 'built' || github.event_name == 'pull_request'
+        uses: actions/download-artifact@v2
+        with:
+          name: dist
+          path: dist
+      - if: matrix.target == 'built' || github.event_name == 'pull_request'
+        uses: actions/download-artifact@v2
+        with:
+          name: action.yml
+          path: .
+
+      - name: Create change
+        run: date +%s > report.txt
+
+      - name: Create Pull Request
+        id: cpr
+        uses: ./
+        with:
+          commit-message: '[CI] test ${{ matrix.target }}'
+          committer: GitHub <noreply@github.com>
+          author: ${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>
+          title: '[CI] test ${{ matrix.target }}'
+          body: |
+            - CI test case for target '${{ matrix.target }}'
+
+            Auto-generated by [create-pull-request][1]
+
+            [1]: https://github.com/peter-evans/create-pull-request
+          branch: ci-test-${{ matrix.target }}
+
+      - name: Close Pull
+        uses: peter-evans/close-pull@v1
+        with:
+          pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}
+          comment: '[CI] test ${{ matrix.target }}'
+          delete-branch: true
+
+  commentTestSuiteHelp:
+    if: github.event_name == 'pull_request'
+    needs: [test]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Find Comment
+        uses: peter-evans/find-comment@v1
+        id: fc
+        with:
+          issue-number: ${{ github.event.number }}
+          comment-author: 'github-actions[bot]'
+          body-includes: Full test suite slash command
+
+      - if: steps.fc.outputs.comment-id == ''
+        name: Create comment
+        uses: peter-evans/create-or-update-comment@v1
+        with:
+          issue-number: ${{ github.event.number }}
+          body: |
+            Full test suite slash command (repository admin only)
+            ```
+            /test repository=${{ github.event.pull_request.head.repo.full_name }} ref=${{ github.event.pull_request.head.ref }} build=true
+            ```
+
+  package:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: [test]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/download-artifact@v2
+        with:
+          name: dist
+          path: dist
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          commit-message: 'build: update distribution'
+          title: Update distribution
+          body: |
+            - Updates the distribution for changes on `main`
+
+            Auto-generated by [create-pull-request][1]
+
+            [1]: https://github.com/peter-evans/create-pull-request
+          branch: update-distribution

.github/workflows/cpr-example-command.yml

@@ -7,37 +7,43 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Create report file
+
+      - name: Make changes to pull request
         run: date +%s > report.txt
+
       - name: Create Pull Request
         id: cpr
         uses: ./
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: Add report file
-          committer: Peter Evans <peter-evans@users.noreply.github.com>
-          title: '[Example] Add report file'
+          commit-message: Update report
+          committer: GitHub <noreply@github.com>
+          author: ${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>
+          signoff: false
+          title: '[Example] Update report'
           body: |
-            New report
-            - Contains *today's* date
+            Update report
+            - Updated with *today's* date
             - Auto-generated by [create-pull-request][1]
 
             [1]: https://github.com/peter-evans/create-pull-request
-          labels: report, automated pr
+          labels: |
+            report
+            automated pr
           assignees: peter-evans
           reviewers: peter-evans
           milestone: 1
-          project: Example Project
-          project-column: To do
+          draft: false
           branch: example-patches
-      - name: Check outputs
+          delete-branch: true
+
+      - name: Check output
         run: |
-          echo "Pull Request Number - ${{ env.PULL_REQUEST_NUMBER }}"
-          echo "Pull Request Number - ${{ steps.cpr.outputs.pr_number }}"
+          echo "Pull Request Number - ${{ steps.cpr.outputs.pull-request-number }}"
+          echo "Pull Request URL - ${{ steps.cpr.outputs.pull-request-url }}"
+
       - name: Add reaction
         uses: peter-evans/create-or-update-comment@v1
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           repository: ${{ github.event.client_payload.github.payload.repository.full_name }}
           comment-id: ${{ github.event.client_payload.github.payload.comment.id }}
           reaction-type: hooray

.github/workflows/dockerhub-description.yml

@@ -1,19 +0,0 @@
-name: Update Docker Hub Description
-on:
-  push:
-    branches:
-      - master
-    paths:
-      - README.md
-      - .github/workflows/dockerhub-description.yml
-jobs:
-  dockerHubDescription:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-    - name: Docker Hub Description
-      uses: peter-evans/dockerhub-description@v2.1.0
-      env:
-        DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-        DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
-        DOCKERHUB_REPOSITORY: peterevans/create-pull-request

.github/workflows/slash-command-dispatch.yml

@@ -7,10 +7,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Slash Command Dispatch
-        uses: peter-evans/slash-command-dispatch@v1
+        uses: peter-evans/slash-command-dispatch@v2
         with:
-          token: ${{ secrets.REPO_ACCESS_TOKEN }}
-          reaction-token: ${{ secrets.GITHUB_TOKEN }}
+          token: ${{ secrets.ACTIONS_BOT_TOKEN }}
           config: >
             [
               {
@@ -19,12 +18,6 @@ jobs:
                 "repository": "peter-evans/create-pull-request-tests",
                 "named_args": true
               },
-              {
-                "command": "pytest",
-                "permission": "admin",
-                "repository": "peter-evans/create-pull-request-tests",
-                "named_args": true
-              },
               {
                 "command": "clean",
                 "permission": "admin",
@@ -34,5 +27,11 @@ jobs:
                 "command": "cpr-example",
                 "permission": "admin",
                 "issue_type": "issue"
+              },
+              {
+                "command": "rebase",
+                "permission": "admin",
+                "repository": "peter-evans/slash-command-dispatch-processor",
+                "issue_type": "pull-request"
               }
             ]

.gitignore

@@ -1,6 +1,5 @@
-__pycache__
-.python-version
-
-node_modules
+lib/
+node_modules/
 
 .DS_Store
+.idea

.prettierignore

@@ -0,0 +1,3 @@
+dist/
+lib/
+node_modules/

.prettierrc.json

@@ -0,0 +1,11 @@
+{
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "bracketSpacing": false,
+  "arrowParens": "avoid",
+  "parser": "typescript"
+}

README.md

@@ -1,5 +1,6 @@
 # <img width="24" height="24" src="docs/assets/logo.svg"> Create Pull Request
-[![GitHub Marketplace](https://img.shields.io/badge/Marketplace-Create%20Pull%20Request-blue.svg?colorA=24292e&colorB=0366d6&style=flat&longCache=true&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAM6wAADOsB5dZE0gAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAERSURBVCiRhZG/SsMxFEZPfsVJ61jbxaF0cRQRcRJ9hlYn30IHN/+9iquDCOIsblIrOjqKgy5aKoJQj4O3EEtbPwhJbr6Te28CmdSKeqzeqr0YbfVIrTBKakvtOl5dtTkK+v4HfA9PEyBFCY9AGVgCBLaBp1jPAyfAJ/AAdIEG0dNAiyP7+K1qIfMdonZic6+WJoBJvQlvuwDqcXadUuqPA1NKAlexbRTAIMvMOCjTbMwl1LtI/6KWJ5Q6rT6Ht1MA58AX8Apcqqt5r2qhrgAXQC3CZ6i1+KMd9TRu3MvA3aH/fFPnBodb6oe6HM8+lYHrGdRXW8M9bMZtPXUji69lmf5Cmamq7quNLFZXD9Rq7v0Bpc1o/tp0fisAAAAASUVORK5CYII=)](https://github.com/marketplace/actions/create-pull-request)
+[![CI](https://github.com/peter-evans/create-pull-request/workflows/CI/badge.svg)](https://github.com/peter-evans/create-pull-request/actions?query=workflow%3ACI)
+[![GitHub Marketplace](https://img.shields.io/badge/Marketplace-Create%20Pull%20Request-blue.svg?colorA=24292e&colorB=0366d6&style=flat&longCache=true&logo=github)](https://github.com/marketplace/actions/create-pull-request)
 
 A GitHub action to create a pull request for changes to your repository in the actions workspace.
 
@@ -20,112 +21,147 @@ Create Pull Request action will:
 
 - [Concepts, guidelines and advanced usage](docs/concepts-guidelines.md)
 - [Examples](docs/examples.md)
-- [Updating from v1](docs/updating.md)
+- [Updating to v3](docs/updating.md)
 
 ## Usage
 
 ```yml
+      - uses: actions/checkout@v2
+
+      # Make changes to pull request here
+
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+        uses: peter-evans/create-pull-request@v3
 ```
 
-You can also pin to a [specific release](https://github.com/peter-evans/create-pull-request/releases) version in the format `@v2.x.x`
+You can also pin to a [specific release](https://github.com/peter-evans/create-pull-request/releases) version in the format `@v3.x.x`
 
 ### Action inputs
 
-With the exception of `token`, all inputs are **optional**. If not set, sensible default values will be used.
+All inputs are **optional**. If not set, sensible defaults will be used.
 
-**Note**: If you want pull requests created by this action to trigger an `on: push` or `on: pull_request` workflow then you must use a [Personal Access Token](https://help.github.com/en/articles/creating-a-personal-access-token-for-the-command-line) instead of the default `GITHUB_TOKEN`. Alternatively, allow the action to [push using SSH](https://github.com/peter-evans/create-pull-request/blob/master/docs/concepts-guidelines.md#push-using-ssh-deploy-keys) by configuring a deploy key.
+**Note**: If you want pull requests created by this action to trigger an `on: push` or `on: pull_request` workflow then you cannot use the default `GITHUB_TOKEN`. See the [documentation here](docs/concepts-guidelines.md#triggering-further-workflow-runs) for workarounds.
 
 | Name | Description | Default |
 | --- | --- | --- |
-| `token` | `GITHUB_TOKEN` or a `repo` scoped [PAT](https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line). | |
-| `path` | Relative path under `$GITHUB_WORKSPACE` to the repository. | `$GITHUB_WORKSPACE` |
+| `token` | `GITHUB_TOKEN` (`contents: write`, `pull-requests: write`) or a `repo` scoped [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token). | `GITHUB_TOKEN` |
+| `path` | Relative path under `GITHUB_WORKSPACE` to the repository. | `GITHUB_WORKSPACE` |
+| `add-paths` | A comma or newline-separated list of file paths to commit. Paths should follow git's [pathspec](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefpathspecapathspec) syntax. Defaults to adding all new and modified files. See [Add specific paths](#add-specific-paths). | `-A` |
 | `commit-message` | The message to use when committing changes. | `[create-pull-request] automated change` |
-| `committer` | The committer name and email address in the format `Display Name <email@address.com>`. | Defaults to the GitHub Actions bot user. See [Committer and author](#committer-and-author) for details. |
-| `author` | The author name and email address in the format `Display Name <email@address.com>`. | Defaults to the GitHub Actions bot user. See [Committer and author](#committer-and-author) for details. |
+| `committer` | The committer name and email address in the format `Display Name <email@address.com>`. Defaults to the GitHub Actions bot user. | `GitHub <noreply@github.com>` |
+| `author` | The author name and email address in the format `Display Name <email@address.com>`. Defaults to the user who triggered the workflow run. | `${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>` |
+| `signoff` | Add [`Signed-off-by`](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt---signoff) line by the committer at the end of the commit log message. | `false` |
+| `branch` | The pull request branch name. | `create-pull-request/patch` |
+| `delete-branch` | Delete the `branch` when closing pull requests, and when undeleted after merging. Recommend `true`. | `false` |
+| `branch-suffix` | The branch suffix type when using the alternative branching strategy. Valid values are `random`, `timestamp` and `short-commit-hash`. See [Alternative strategy](#alternative-strategy---always-create-a-new-pull-request-branch) for details. | |
+| `base` | Sets the pull request base branch. | Defaults to the branch checked out in the workflow. |
+| `push-to-fork` | A fork of the checked-out parent repository to which the pull request branch will be pushed. e.g. `owner/repo-fork`. The pull request will be created to merge the fork's branch into the parent's base. See [push pull request branches to a fork](docs/concepts-guidelines.md#push-pull-request-branches-to-a-fork) for details. | |
 | `title` | The title of the pull request. | `Changes by create-pull-request action` |
 | `body` | The body of the pull request. | `Automated changes by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action` |
-| `labels` | A comma separated list of labels. | |
-| `assignees` | A comma separated list of assignees (GitHub usernames). | |
-| `reviewers` | A comma separated list of reviewers (GitHub usernames) to request a review from. | |
-| `team-reviewers` | A comma separated list of GitHub teams to request a review from. | |
+| `labels` | A comma or newline-separated list of labels. | |
+| `assignees` | A comma or newline-separated list of assignees (GitHub usernames). | |
+| `reviewers` | A comma or newline-separated list of reviewers (GitHub usernames) to request a review from. | |
+| `team-reviewers` | A comma or newline-separated list of GitHub teams to request a review from. Note that a `repo` scoped [PAT](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) may be required. See [this issue](https://github.com/peter-evans/create-pull-request/issues/155). If using a GitHub App, refer to [Authenticating with GitHub App generated tokens](docs/concepts-guidelines.md#authenticating-with-github-app-generated-tokens) for the proper permissions. | |
 | `milestone` | The number of the milestone to associate this pull request with. | |
-| `project` | The name of the project for which a card should be created. Requires `project-column`. | |
-| `project-column` | The name of the project column under which a card should be created. Requires `project`. | |
-| `branch` | The branch name. See [Branch naming](#branch-naming) for details. | `create-pull-request/patch` |
-| `base` | Sets the pull request base branch. | Defaults to the branch checked out in the workflow. |
-| `branch-suffix` | The branch suffix type. Valid values are `random`, `timestamp` and `short-commit-hash`. See [Branch naming](#branch-naming) for details. | |
+| `draft` | Create a [draft pull request](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests#draft-pull-requests). It is not possible to change draft status after creation except through the web interface. | `false` |
 
-**Outputs**
+For self-hosted runners behind a corporate proxy set the `https_proxy` environment variable.
+```yml
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        env:
+          https_proxy: http://<proxy_address>:<port>
+```
 
-The pull request number is output as both an environment variable and a step output.
-Note that in order to read the step output the action step must have an id.
+### Action outputs
+
+The following outputs can be used by subsequent workflow steps.
+
+- `pull-request-number` - The pull request number.
+- `pull-request-url` - The URL of the pull request.
+- `pull-request-operation` - The pull request operation performed by the action, `created`, `updated` or `closed`.
+- `pull-request-head-sha` - The commit SHA of the pull request branch.
+
+Step outputs can be accessed as in the following example.
+Note that in order to read the step outputs the action step must have an id.
 
 ```yml
       - name: Create Pull Request
         id: cpr
-        uses: peter-evans/create-pull-request@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+        uses: peter-evans/create-pull-request@v3
       - name: Check outputs
         run: |
-          echo "Pull Request Number - ${{ env.PULL_REQUEST_NUMBER }}"
-          echo "Pull Request Number - ${{ steps.cpr.outputs.pr_number }}"
+          echo "Pull Request Number - ${{ steps.cpr.outputs.pull-request-number }}"
+          echo "Pull Request URL - ${{ steps.cpr.outputs.pull-request-url }}"
 ```
 
-### Checkout
+### Action behaviour
 
-This action expects repositories to be checked out with `actions/checkout@v2`.
+The default behaviour of the action is to create a pull request that will be continually updated with new changes until it is merged or closed.
+Changes are committed and pushed to a fixed-name branch, the name of which can be configured with the `branch` input.
+Any subsequent changes will be committed to the *same* branch and reflected in the open pull request.
 
-If there is some reason you need to use `actions/checkout@v1` the following step can be added to checkout the branch.
+How the action behaves:
 
-```yml
-      - uses: actions/checkout@v1
-      - run: git checkout "${GITHUB_REF:11}"
-```
+- If there are changes (i.e. a diff exists with the checked-out base branch), the changes will be pushed to a new `branch` and a pull request created.
+- If there are no changes (i.e. no diff exists with the checked-out base branch), no pull request will be created and the action exits silently.
+- If a pull request already exists and there are no further changes (i.e. no diff with the current pull request branch) then the action exits silently.
+- If a pull request exists and new changes on the base branch make the pull request unnecessary (i.e. there is no longer a diff between the pull request branch and the base), the pull request is automatically closed. Additionally, if `delete-branch` is set to `true` the `branch` will be deleted.
 
-### Branch naming
+For further details about how the action works and usage guidelines, see [Concepts, guidelines and advanced usage](docs/concepts-guidelines.md).
 
-For branch naming there are two strategies. Create a fixed-name pull request branch that will be updated with new changes until it is merged or closed, OR, always create a new unique branch each time there are changes to be committed.
+#### Alternative strategy - Always create a new pull request branch
 
-#### Strategy A - Create and update a pull request branch (default)
+For some use cases it may be desirable to always create a new unique branch each time there are changes to be committed.
+This strategy is *not recommended* because if not used carefully it could result in multiple pull requests being created unnecessarily. If in doubt, use the [default strategy](#action-behaviour) of creating an updating a fixed-name branch.
 
-This strategy is the default behaviour of the action. The input `branch` defaults to `create-pull-request/patch`. Changes will be committed to this branch and a pull request created. Any subsequent changes will be committed to the *same* branch and reflected in the open pull request. If the pull request is merged or closed a new one will be created. If subsequent changes cause the branch to no longer differ from the base the pull request will be automatically closed and the branch deleted.
+To use this strategy, set input `branch-suffix` with one of the following options.
 
-#### Strategy B - Always create a new pull request branch
-
-For this strategy there are three options to suffix the branch name.
-The branch name is defined by the input `branch` and defaults to `create-pull-request/patch`. The following options are values for `branch-suffix`.
-
-- `random` - Commits will be made to a branch suffixed with a random alpha-numeric string. This option should be used if multiple pull requests will be created during the execution of a workflow. e.g. `create-pull-request/patch-6qj97jr`, `create-pull-request/patch-5jrjhvd`
+- `random` - Commits will be made to a branch suffixed with a random alpha-numeric string. e.g. `create-pull-request/patch-6qj97jr`, `create-pull-request/patch-5jrjhvd`
 
 - `timestamp` - Commits will be made to a branch suffixed by a timestamp. e.g. `create-pull-request/patch-1569322532`, `create-pull-request/patch-1569322552`
 
 - `short-commit-hash` - Commits will be made to a branch suffixed with the short SHA1 commit hash. e.g. `create-pull-request/patch-fcdfb59`, `create-pull-request/patch-394710b`
 
-### Ignoring files
+### Controlling committed files
+
+The action defaults to adding all new and modified files.
+If there are files that should not be included in the pull request, you can use the following methods to control the committed content.
+
+#### Remove files
+
+The most straightforward way to handle unwanted files is simply to remove them in a step before the action runs.
+
+```yml
+      - run: |
+          rm -rf temp-dir
+          rm temp-file.txt
+```
+
+#### Ignore files
 
 If there are files or directories you want to ignore you can simply add them to a `.gitignore` file at the root of your repository. The action will respect this file.
 
-### Committer and author
+#### Add specific paths
 
-If neither `committer` or `author` inputs are supplied the action will default to making commits that appear to be made by the GitHub Actions bot user.
+You can control which files are committed with the `add-paths` input.
+Paths should follow git's [pathspec](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefpathspecapathspec) syntax.
+Each path must resolve to a least one new or modified file to add.
+All file changes that do not match one of the paths will be discarded.
 
-In most cases, where the committer and author are the same, just the committer can be set.
 ```yml
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          committer: Peter Evans <peter-evans@users.noreply.github.com>
+          add-paths: |
+            *.java
+            docs/*.md
 ```
 
-### Controlling commits
+#### Create your own commits
 
 As well as relying on the action to handle uncommitted changes, you can additionally make your own commits before the action runs.
+Note that the repository must be checked out on a branch with a remote, it won't work for [events which checkout a commit](docs/concepts-guidelines.md#events-which-checkout-a-commit).
 
 ```yml
     steps:
@@ -142,56 +178,79 @@ As well as relying on the action to handle uncommitted changes, you can addition
       - name: Uncommitted change
         run: date +%s > report.txt
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+        uses: peter-evans/create-pull-request@v3
 ```
 
+### Create a project card
+
+To create a project card for the pull request, pass the `pull-request-number` step output to [create-or-update-project-card](https://github.com/peter-evans/create-or-update-project-card) action.
+
+```yml
+      - name: Create Pull Request
+        id: cpr
+        uses: peter-evans/create-pull-request@v3
+
+      - name: Create or Update Project Card
+        uses: peter-evans/create-or-update-project-card@v1
+        with:
+          project-name: My project
+          column-name: My column
+          issue-number: ${{ steps.cpr.outputs.pull-request-number }}
+```
+
+### Auto-merge
+
+Auto-merge can be enabled on a pull request allowing it to be automatically merged once requirements have been satisfied.
+See [enable-pull-request-automerge](https://github.com/peter-evans/enable-pull-request-automerge) action for usage details.
+
 ## Reference Example
 
-The following workflow is a reference example that sets all the main inputs.
+The following workflow sets many of the action's inputs for reference purposes.
+Check the [defaults](#action-inputs) to avoid setting inputs unnecessarily.
 
 See [examples](docs/examples.md) for more realistic use cases.
 
 ```yml
-name: Create Pull Request
-on: push
 jobs:
   createPullRequest:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Create report file
+
+      - name: Make changes to pull request
         run: date +%s > report.txt
+
       - name: Create Pull Request
         id: cpr
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: Add report file
-          committer: Peter Evans <peter-evans@users.noreply.github.com>
-          author: Peter Evans <peter-evans@users.noreply.github.com>
-          title: '[Example] Add report file'
+          token: ${{ secrets.PAT }}
+          commit-message: Update report
+          committer: GitHub <noreply@github.com>
+          author: ${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>
+          signoff: false
+          branch: example-patches
+          delete-branch: true
+          title: '[Example] Update report'
           body: |
-            New report
-            - Contains *today's* date
+            Update report
+            - Updated with *today's* date
             - Auto-generated by [create-pull-request][1]
 
             [1]: https://github.com/peter-evans/create-pull-request
-          labels: report, automated pr
+          labels: |
+            report
+            automated pr
           assignees: peter-evans
           reviewers: peter-evans
+          team-reviewers: |
+            owners
+            maintainers
           milestone: 1
-          project: Example Project
-          project-column: To do
-          branch: example-patches
-      - name: Check outputs
-        run: |
-          echo "Pull Request Number - ${{ env.PULL_REQUEST_NUMBER }}"
-          echo "Pull Request Number - ${{ steps.cpr.outputs.pr_number }}"
+          draft: false
 ```
 
-This reference configuration will create pull requests that look like this:
+An example based on the above reference configuration creates pull requests that look like this:
 
 ![Pull Request Example](docs/assets/pull-request-example.png)
 

__test__/entrypoint.sh

@@ -0,0 +1,40 @@
+#!/bin/sh -l
+set -euo pipefail
+
+# Save the working directory
+WORKINGDIR=$PWD
+
+# Create and serve a remote repo
+mkdir -p /git/remote
+git init --bare /git/remote/test-base.git
+git daemon --verbose --enable=receive-pack --base-path=/git/remote --export-all /git/remote &>/dev/null &
+
+# Give the daemon time to start
+sleep 2
+
+# Create a local clone and make an initial commit
+mkdir -p /git/local
+git clone git://127.0.0.1/test-base.git /git/local/test-base
+cd /git/local/test-base
+git config --global user.email "you@example.com"
+git config --global user.name "Your Name"
+echo "#test-base" > README.md
+git add .
+git commit -m "initial commit"
+git push -u
+git log -1 --pretty=oneline
+git config --global --unset user.email
+git config --global --unset user.name
+git config -l
+
+# Clone a server-side fork of the base repo
+cd $WORKINGDIR
+git clone --mirror git://127.0.0.1/test-base.git /git/remote/test-fork.git
+cd /git/remote/test-fork.git
+git log -1 --pretty=oneline
+
+# Restore the working directory
+cd $WORKINGDIR
+
+# Execute integration tests
+jest int --runInBand

__test__/git-auth-helper.int.test.ts

@@ -0,0 +1,49 @@
+import {GitCommandManager} from '../lib/git-command-manager'
+import {GitAuthHelper} from '../lib/git-auth-helper'
+
+const REPO_PATH = '/git/local/test-base'
+
+const extraheaderConfigKey = 'http.https://github.com/.extraheader'
+
+describe('git-auth-helper tests', () => {
+  let git: GitCommandManager
+  let gitAuthHelper: GitAuthHelper
+
+  beforeAll(async () => {
+    git = await GitCommandManager.create(REPO_PATH)
+    gitAuthHelper = new GitAuthHelper(git)
+  })
+
+  it('tests save and restore with no persisted auth', async () => {
+    await gitAuthHelper.savePersistedAuth()
+    await gitAuthHelper.restorePersistedAuth()
+  })
+
+  it('tests configure and removal of auth', async () => {
+    await gitAuthHelper.configureToken('github-token')
+    expect(await git.configExists(extraheaderConfigKey)).toBeTruthy()
+    expect(await git.getConfigValue(extraheaderConfigKey)).toEqual(
+      'AUTHORIZATION: basic eC1hY2Nlc3MtdG9rZW46Z2l0aHViLXRva2Vu'
+    )
+
+    await gitAuthHelper.removeAuth()
+    expect(await git.configExists(extraheaderConfigKey)).toBeFalsy()
+  })
+
+  it('tests save and restore of persisted auth', async () => {
+    const extraheaderConfigValue = 'AUTHORIZATION: basic ***persisted-auth***'
+    await git.config(extraheaderConfigKey, extraheaderConfigValue)
+
+    await gitAuthHelper.savePersistedAuth()
+
+    const exists = await git.configExists(extraheaderConfigKey)
+    expect(exists).toBeFalsy()
+
+    await gitAuthHelper.restorePersistedAuth()
+
+    const configValue = await git.getConfigValue(extraheaderConfigKey)
+    expect(configValue).toEqual(extraheaderConfigValue)
+
+    await gitAuthHelper.removeAuth()
+  })
+})

__test__/integration-tests.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+IMAGE="cpr-integration-tests:latest"
+ARG1=${1:-}
+
+if [[ "$(docker images -q $IMAGE 2> /dev/null)" == "" || $ARG1 == "build" ]]; then
+    echo "Building Docker image $IMAGE ..."
+
+    cat > Dockerfile << EOF
+FROM node:12-alpine
+RUN apk --no-cache add git git-daemon
+RUN npm install jest --global
+WORKDIR /cpr
+COPY __test__/entrypoint.sh /entrypoint.sh
+ENTRYPOINT ["/entrypoint.sh"]
+EOF
+
+    docker build --no-cache -t $IMAGE .
+    rm Dockerfile
+fi
+
+docker run -v $PWD:/cpr $IMAGE

__test__/utils.unit.test.ts

@@ -0,0 +1,124 @@
+import * as path from 'path'
+import * as utils from '../lib/utils'
+
+const originalGitHubWorkspace = process.env['GITHUB_WORKSPACE']
+
+describe('utils tests', () => {
+  beforeAll(() => {
+    // GitHub workspace
+    process.env['GITHUB_WORKSPACE'] = __dirname
+  })
+
+  afterAll(() => {
+    // Restore GitHub workspace
+    delete process.env['GITHUB_WORKSPACE']
+    if (originalGitHubWorkspace) {
+      process.env['GITHUB_WORKSPACE'] = originalGitHubWorkspace
+    }
+  })
+
+  test('getStringAsArray splits string input by newlines and commas', async () => {
+    const array = utils.getStringAsArray('1, 2, 3\n4, 5, 6')
+    expect(array.length).toEqual(6)
+
+    const array2 = utils.getStringAsArray('')
+    expect(array2.length).toEqual(0)
+  })
+
+  test('getRepoPath successfully returns the path to the repository', async () => {
+    expect(utils.getRepoPath()).toEqual(process.env['GITHUB_WORKSPACE'])
+    expect(utils.getRepoPath('foo')).toEqual(
+      path.resolve(process.env['GITHUB_WORKSPACE'] || '', 'foo')
+    )
+  })
+
+  test('getRemoteDetail successfully parses remote URLs', async () => {
+    const remote1 = utils.getRemoteDetail(
+      'https://github.com/peter-evans/create-pull-request'
+    )
+    expect(remote1.protocol).toEqual('HTTPS')
+    expect(remote1.repository).toEqual('peter-evans/create-pull-request')
+
+    const remote2 = utils.getRemoteDetail(
+      'https://xxx:x-oauth-basic@github.com/peter-evans/create-pull-request'
+    )
+    expect(remote2.protocol).toEqual('HTTPS')
+    expect(remote2.repository).toEqual('peter-evans/create-pull-request')
+
+    const remote3 = utils.getRemoteDetail(
+      'git@github.com:peter-evans/create-pull-request.git'
+    )
+    expect(remote3.protocol).toEqual('SSH')
+    expect(remote3.repository).toEqual('peter-evans/create-pull-request')
+  })
+
+  test('getRemoteDetail fails to parse a remote URL', async () => {
+    const remoteUrl = 'https://github.com/peter-evans'
+    try {
+      utils.getRemoteDetail(remoteUrl)
+      // Fail the test if an error wasn't thrown
+      expect(true).toEqual(false)
+    } catch (e: any) {
+      expect(e.message).toEqual(
+        `The format of '${remoteUrl}' is not a valid GitHub repository URL`
+      )
+    }
+  })
+
+  test('getRemoteUrl successfully returns remote URLs', async () => {
+    const url1 = utils.getRemoteUrl('HTTPS', 'peter-evans/create-pull-request')
+    expect(url1).toEqual('https://github.com/peter-evans/create-pull-request')
+
+    const url2 = utils.getRemoteUrl('SSH', 'peter-evans/create-pull-request')
+    expect(url2).toEqual('git@github.com:peter-evans/create-pull-request.git')
+  })
+
+  test('secondsSinceEpoch returns the number of seconds since the Epoch', async () => {
+    const seconds = `${utils.secondsSinceEpoch()}`
+    expect(seconds.length).toEqual(10)
+  })
+
+  test('randomString returns strings of length 7', async () => {
+    for (let i = 0; i < 1000; i++) {
+      expect(utils.randomString().length).toEqual(7)
+    }
+  })
+
+  test('parseDisplayNameEmail successfully parses display name email formats', async () => {
+    const parsed1 = utils.parseDisplayNameEmail('abc def <abc@def.com>')
+    expect(parsed1.name).toEqual('abc def')
+    expect(parsed1.email).toEqual('abc@def.com')
+
+    const parsed2 = utils.parseDisplayNameEmail(
+      'github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>'
+    )
+    expect(parsed2.name).toEqual('github-actions[bot]')
+    expect(parsed2.email).toEqual(
+      '41898282+github-actions[bot]@users.noreply.github.com'
+    )
+  })
+
+  test('parseDisplayNameEmail fails to parse display name email formats', async () => {
+    const displayNameEmail1 = 'abc@def.com'
+    try {
+      utils.parseDisplayNameEmail(displayNameEmail1)
+      // Fail the test if an error wasn't thrown
+      expect(true).toEqual(false)
+    } catch (e: any) {
+      expect(e.message).toEqual(
+        `The format of '${displayNameEmail1}' is not a valid email address with display name`
+      )
+    }
+
+    const displayNameEmail2 = ' < >'
+    try {
+      utils.parseDisplayNameEmail(displayNameEmail2)
+      // Fail the test if an error wasn't thrown
+      expect(true).toEqual(false)
+    } catch (e: any) {
+      expect(e.message).toEqual(
+        `The format of '${displayNameEmail2}' is not a valid email address with display name`
+      )
+    }
+  })
+})

action.yml

@@ -2,46 +2,87 @@ name: 'Create Pull Request'
 description: 'Creates a pull request for changes to your repository in the actions workspace'
 inputs:
   token:
-    description: 'GITHUB_TOKEN or a repo scoped PAT'
-    required: true
+    description: 'GITHUB_TOKEN or a `repo` scoped Personal Access Token (PAT)'
+    default: ${{ github.token }}
   path:
-    description: 'Relative path under $GITHUB_WORKSPACE to the repository.'
+    description: >
+      Relative path under $GITHUB_WORKSPACE to the repository.
+      Defaults to $GITHUB_WORKSPACE.
+  add-paths:
+    description: >
+      A comma or newline-separated list of file paths to commit.
+      Paths should follow git's pathspec syntax.
+      Defaults to adding all new and modified files.
+    default: |
+      -A
   commit-message:
     description: 'The message to use when committing changes.'
+    default: '[create-pull-request] automated change'
   committer:
-    description: 'The committer name and email address.'
+    description: >
+      The committer name and email address in the format `Display Name <email@address.com>`.
+      Defaults to the GitHub Actions bot user.
+    default: 'GitHub <noreply@github.com>'
   author:
-    description: 'The author name and email address.'
-  title:
-    description: 'The title of the pull request.'
-  body:
-    description: 'The body of the pull request.'
-  labels:
-    description: 'A comma separated list of labels.'
-  assignees:
-    description: 'A comma separated list of assignees (GitHub usernames).'
-  reviewers:
-    description: 'A comma separated list of reviewers (GitHub usernames) to request a review from.'
-  team-reviewers:
-    description: 'A comma separated list of GitHub teams to request a review from.'
-  milestone:
-    description: 'The number of the milestone to associate this pull request with.'
-  project:
-    description: 'The name of the project for which a card should be created.'
-  project-column:
-    description: 'The name of the project column under which a card should be created.'
+    description: >
+      The author name and email address in the format `Display Name <email@address.com>`.
+      Defaults to the user who triggered the workflow run.
+    default: '${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>'
+  signoff:
+    description: 'Add `Signed-off-by` line by the committer at the end of the commit log message.'
+    default: false
   branch:
     description: 'The pull request branch name.'
-  base:
-    description: 'The pull request base branch.'
+    default: 'create-pull-request/patch'
+  delete-branch:
+    description: >
+      Delete the `branch` when closing pull requests, and when undeleted after merging.
+      Recommend `true`.
+    default: false
   branch-suffix:
-    description: 'The branch suffix type.'
+    description: 'The branch suffix type when using the alternative branching strategy.'
+  base:
+    description: >
+      The pull request base branch.
+      Defaults to the branch checked out in the workflow.
+  push-to-fork:
+    description: >
+      A fork of the checked out parent repository to which the pull request branch will be pushed.
+      e.g. `owner/repo-fork`.
+      The pull request will be created to merge the fork's branch into the parent's base.
+  title:
+    description: 'The title of the pull request.'
+    default: 'Changes by create-pull-request action'
+  body:
+    description: 'The body of the pull request.'
+    default: 'Automated changes by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action'
+  labels:
+    description: 'A comma or newline separated list of labels.'
+  assignees:
+    description: 'A comma or newline separated list of assignees (GitHub usernames).'
+  reviewers:
+    description: 'A comma or newline separated list of reviewers (GitHub usernames) to request a review from.'
+  team-reviewers:
+    description: >
+      A comma or newline separated list of GitHub teams to request a review from.
+      Note that a `repo` scoped Personal Access Token (PAT) may be required.
+  milestone:
+    description: 'The number of the milestone to associate the pull request with.'
+  draft:
+    description: 'Create a draft pull request. It is not possible to change draft status after creation except through the web interface'
+    default: false
 outputs:
-  pr_number:
+  pull-request-number:
     description: 'The pull request number'
+  pull-request-url:
+    description: 'The URL of the pull request.'
+  pull-request-operation:
+    description: 'The pull request operation performed by the action, `created`, `updated` or `closed`.'
+  pull-request-head-sha:
+    description: 'The commit SHA of the pull request branch.'
 runs:
   using: 'node12'
   main: 'dist/index.js'
 branding:
-  icon: 'git-pull-request'  
+  icon: 'git-pull-request'
   color: 'gray-dark'

dist/src/common.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-import random
-import re
-import string
-
-
-def get_random_string(length=7, chars=string.ascii_lowercase + string.digits):
-    return "".join(random.choice(chars) for _ in range(length))
-
-
-def parse_github_repository(url):
-    # Parse the protocol and github repository from a URL
-    # e.g. HTTPS, peter-evans/create-pull-request
-    https_pattern = re.compile(r"^https://github.com/(.+/.+)$")
-    ssh_pattern = re.compile(r"^git@github.com:(.+/.+).git$")
-
-    match = https_pattern.match(url)
-    if match is not None:
-        return "HTTPS", match.group(1)
-
-    match = ssh_pattern.match(url)
-    if match is not None:
-        return "SSH", match.group(1)
-
-    raise ValueError(f"The format of '{url}' is not a valid GitHub repository URL")
-
-
-def parse_display_name_email(display_name_email):
-    # Parse the name and email address from a string in the following format
-    # Display Name <email@address.com>
-    pattern = re.compile(r"^([^<]+)\s*<([^>]+)>$")
-
-    # Check we have a match
-    match = pattern.match(display_name_email)
-    if match is None:
-        raise ValueError(
-            f"The format of '{display_name_email}' is not a valid email address with display name"
-        )
-
-    # Check that name and email are not just whitespace
-    name = match.group(1).strip()
-    email = match.group(2).strip()
-    if len(name) == 0 or len(email) == 0:
-        raise ValueError(
-            f"The format of '{display_name_email}' is not a valid email address with display name"
-        )
-
-    return name, email

dist/src/create_or_update_branch.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-""" Create or Update Branch """
-import common as cmn
-from git import Repo, GitCommandError
-import os
-
-
-CHERRYPICK_EMPTY = (
-    "The previous cherry-pick is now empty, possibly due to conflict resolution."
-)
-
-
-def fetch_successful(repo, repo_url, branch):
-    try:
-        repo.git.fetch(repo_url, f"{branch}:refs/remotes/origin/{branch}")
-    except GitCommandError:
-        return False
-    return True
-
-
-def is_ahead(repo, branch_1, branch_2):
-    # Return true if branch_2 is ahead of branch_1
-    return (
-        int(repo.git.rev_list("--right-only", "--count", f"{branch_1}...{branch_2}"))
-        > 0
-    )
-
-
-def is_behind(repo, branch_1, branch_2):
-    # Return true if branch_2 is behind branch_1
-    return (
-        int(repo.git.rev_list("--left-only", "--count", f"{branch_1}...{branch_2}")) > 0
-    )
-
-
-def is_even(repo, branch_1, branch_2):
-    # Return true if branch_2 is even with branch_1
-    return not is_ahead(repo, branch_1, branch_2) and not is_behind(
-        repo, branch_1, branch_2
-    )
-
-
-def has_diff(repo, branch_1, branch_2):
-    diff = repo.git.diff(f"{branch_1}..{branch_2}")
-    return len(diff) > 0
-
-
-def create_or_update_branch(repo, repo_url, commit_message, base, branch):
-    # Set the default return values
-    action = "none"
-    diff = False
-
-    # Get the working base. This may or may not be the actual base.
-    working_base = repo.git.symbolic_ref("HEAD", "--short")
-    # If the base is not specified it is assumed to be the working base
-    if base is None:
-        base = working_base
-
-    # Save the working base changes to a temporary branch
-    temp_branch = cmn.get_random_string(length=20)
-    repo.git.checkout("HEAD", b=temp_branch)
-    # Commit any uncomitted changes
-    if repo.is_dirty(untracked_files=True):
-        print(f"Uncommitted changes found. Adding a commit.")
-        repo.git.add("-A")
-        repo.git.commit(m=commit_message)
-
-    # Perform fetch and reset the working base
-    # Commits made during the workflow will be removed
-    repo.git.fetch("--force", repo_url, f"{working_base}:{working_base}")
-
-    # If the working base is not the base, rebase the temp branch commits
-    if working_base != base:
-        print(
-            f"Rebasing commits made to branch '{working_base}' on to base branch '{base}'"
-        )
-        # Checkout the actual base
-        repo.git.fetch("--force", repo_url, f"{base}:{base}")
-        repo.git.checkout(base)
-        # Cherrypick commits from the temporary branch starting from the working base
-        commits = repo.git.rev_list("--reverse", f"{working_base}..{temp_branch}", ".")
-        for commit in commits.splitlines():
-            try:
-                repo.git.cherry_pick(
-                    "--strategy",
-                    "recursive",
-                    "--strategy-option",
-                    "theirs",
-                    f"{commit}",
-                )
-            except GitCommandError as e:
-                if CHERRYPICK_EMPTY not in e.stderr:
-                    print("Unexpected error: ", e)
-                    raise
-        # Reset the temp branch to the working index
-        repo.git.checkout("-B", temp_branch, "HEAD")
-        # Reset the base
-        repo.git.fetch("--force", repo_url, f"{base}:{base}")
-
-    # Try to fetch the pull request branch
-    if not fetch_successful(repo, repo_url, branch):
-        # The pull request branch does not exist
-        print(f"Pull request branch '{branch}' does not exist yet")
-        # Create the pull request branch
-        repo.git.checkout("HEAD", b=branch)
-        # Check if the pull request branch is ahead of the base
-        diff = is_ahead(repo, base, branch)
-        if diff:
-            action = "created"
-            print(f"Created branch '{branch}'")
-        else:
-            print(
-                f"Branch '{branch}' is not ahead of base '{base}' and will not be created"
-            )
-    else:
-        # The pull request branch exists
-        print(
-            f"Pull request branch '{branch}' already exists as remote branch 'origin/{branch}'"
-        )
-        # Checkout the pull request branch
-        repo.git.checkout(branch)
-
-        if has_diff(repo, branch, temp_branch):
-            # If the branch differs from the recreated temp version then the branch is reset
-            # For changes on base this action is similar to a rebase of the pull request branch
-            print(f"Resetting '{branch}'")
-            repo.git.checkout("-B", branch, temp_branch)
-            # repo.git.switch("-C", branch, temp_branch)
-
-        # Check if the pull request branch has been updated
-        # If the branch was reset or updated it will be ahead
-        # It may be behind if a reset now results in no diff with the base
-        if not is_even(repo, f"origin/{branch}", branch):
-            action = "updated"
-            print(f"Updated branch '{branch}'")
-        else:
-            print(f"Branch '{branch}' is even with its remote and will not be updated")
-
-        # Check if the pull request branch is ahead of the base
-        diff = is_ahead(repo, base, branch)
-
-    # Delete the temporary branch
-    repo.git.branch("--delete", "--force", temp_branch)
-
-    return {"action": action, "diff": diff, "base": base}

dist/src/create_or_update_pull_request.py

@@ -1,128 +0,0 @@
-#!/usr/bin/env python3
-""" Create or Update Pull Request """
-from github import Github, GithubException
-import os
-
-
-def cs_string_to_list(str):
-    # Split the comma separated string into a list
-    l = [i.strip() for i in str.split(",")]
-    # Remove empty strings
-    return list(filter(None, l))
-
-
-def create_project_card(github_repo, project_name, project_column_name, pull_request):
-    # Locate the project by name
-    project = None
-    for project_item in github_repo.get_projects("all"):
-        if project_item.name == project_name:
-            project = project_item
-            break
-
-    if not project:
-        print("::error::Project not found. Unable to create project card.")
-        return
-
-    # Locate the column by name
-    column = None
-    for column_item in project.get_columns():
-        if column_item.name == project_column_name:
-            column = column_item
-            break
-
-    if not column:
-        print("::error::Project column not found. Unable to create project card.")
-        return
-
-    # Create a project card for the pull request
-    column.create_card(content_id=pull_request.id, content_type="PullRequest")
-    print(
-        "Added pull request #%d to project '%s' under column '%s'"
-        % (pull_request.number, project.name, column.name)
-    )
-
-
-def create_or_update_pull_request(
-    github_token,
-    github_repository,
-    branch,
-    base,
-    title,
-    body,
-    labels,
-    assignees,
-    milestone,
-    reviewers,
-    team_reviewers,
-    project_name,
-    project_column_name,
-):
-    # Create the pull request
-    github_repo = Github(github_token).get_repo(github_repository)
-    try:
-        pull_request = github_repo.create_pull(
-            title=title, body=body, base=base, head=branch
-        )
-        print(f"Created pull request #{pull_request.number} ({branch} => {base})")
-    except GithubException as e:
-        if e.status == 422:
-            # A pull request exists for this branch and base
-            head_branch = "{}:{}".format(github_repository.split("/")[0], branch)
-            # Get the pull request
-            pull_request = github_repo.get_pulls(
-                state="open", base=base, head=head_branch
-            )[0]
-            # Update title and body
-            pull_request.as_issue().edit(title=title, body=body)
-            print(f"Updated pull request #{pull_request.number} ({branch} => {base})")
-        else:
-            print(str(e))
-            raise
-
-    # Set the output variables
-    os.system(f"echo ::set-env name=PULL_REQUEST_NUMBER::{pull_request.number}")
-    os.system(f"echo ::set-output name=pr_number::{pull_request.number}")
-
-    # Set labels, assignees and milestone
-    if labels is not None:
-        print(f"Applying labels '{labels}'")
-        pull_request.as_issue().edit(labels=cs_string_to_list(labels))
-    if assignees is not None:
-        print(f"Applying assignees '{assignees}'")
-        pull_request.as_issue().edit(assignees=cs_string_to_list(assignees))
-    if milestone is not None:
-        print(f"Applying milestone '{milestone}'")
-        milestone = github_repo.get_milestone(int(milestone))
-        pull_request.as_issue().edit(milestone=milestone)
-
-    # Set pull request reviewers
-    if reviewers is not None:
-        print(f"Requesting reviewers '{reviewers}'")
-        try:
-            pull_request.create_review_request(reviewers=cs_string_to_list(reviewers))
-        except GithubException as e:
-            # Likely caused by "Review cannot be requested from pull request author."
-            if e.status == 422:
-                print("Request reviewers failed - {}".format(e.data["message"]))
-
-    # Set pull request team reviewers
-    if team_reviewers is not None:
-        print(f"Requesting team reviewers '{team_reviewers}'")
-        pull_request.create_review_request(
-            team_reviewers=cs_string_to_list(team_reviewers)
-        )
-
-    # Create a project card for the pull request
-    if project_name is not None and project_column_name is not None:
-        try:
-            create_project_card(
-                github_repo, project_name, project_column_name, pull_request
-            )
-        except GithubException as e:
-            # Likely caused by "Project already has the associated issue."
-            if e.status == 422:
-                print(
-                    "Create project card failed - {}".format(
-                        e.data["errors"][0]["message"]
-                    )
-                )

dist/src/create_pull_request.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-""" Create Pull Request """
-import common as cmn
-import create_or_update_branch as coub
-import create_or_update_pull_request as coupr
-from git import Repo, GitCommandError
-import json
-import os
-import sys
-import time
-
-
-# Default the committer and author to the GitHub Actions bot
-DEFAULT_COMMITTER = "GitHub <noreply@github.com>"
-DEFAULT_AUTHOR = (
-    "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"
-)
-DEFAULT_COMMIT_MESSAGE = "[create-pull-request] automated change"
-DEFAULT_TITLE = "Changes by create-pull-request action"
-DEFAULT_BODY = (
-    "Automated changes by "
-    + "[create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action"
-)
-DEFAULT_BRANCH = "create-pull-request/patch"
-
-
-def get_git_config_value(repo, name):
-    try:
-        return repo.git.config("--get", name)
-    except GitCommandError:
-        return None
-
-
-def get_repository_detail():
-    remote_origin_url = get_git_config_value(repo, "remote.origin.url")
-    if remote_origin_url is None:
-        raise ValueError("Failed to fetch 'remote.origin.url' from git config")
-    protocol, github_repository = cmn.parse_github_repository(remote_origin_url)
-    return remote_origin_url, protocol, github_repository
-
-
-def git_user_config_is_set(repo):
-    name = get_git_config_value(repo, "user.name")
-    email = get_git_config_value(repo, "user.email")
-
-    if name is not None and email is not None:
-        print(f"Git user already configured as '{name} <{email}>'")
-        return True
-
-    committer_name = get_git_config_value(repo, "committer.name")
-    committer_email = get_git_config_value(repo, "committer.email")
-    author_name = get_git_config_value(repo, "author.name")
-    author_email = get_git_config_value(repo, "author.email")
-
-    if (
-        committer_name is not None
-        and committer_email is not None
-        and author_name is not None
-        and author_email is not None
-    ):
-        print(
-            f"Git committer already configured as '{committer_name} <{committer_email}>'"
-        )
-        print(f"Git author already configured as '{author_name} <{author_email}>'")
-        return True
-
-    return False
-
-
-def set_committer_author(repo, committer, author):
-    # If either committer or author is supplied they will be cross used
-    if committer is None and author is not None:
-        print("Supplied author will also be used as the committer.")
-        committer = author
-    if author is None and committer is not None:
-        print("Supplied committer will also be used as the author.")
-        author = committer
-
-    # If no committer/author has been supplied but user configuration already
-    # exists in git config we can exit and use the existing config as-is.
-    if committer is None and author is None:
-        if git_user_config_is_set(repo):
-            return
-
-    # Set defaults if no committer/author has been supplied
-    if committer is None and author is None:
-        committer = DEFAULT_COMMITTER
-        author = DEFAULT_AUTHOR
-
-    # Set git environment. This will not persist after the action completes.
-    committer_name, committer_email = cmn.parse_display_name_email(committer)
-    author_name, author_email = cmn.parse_display_name_email(author)
-    repo.git.update_environment(
-        GIT_COMMITTER_NAME=committer_name,
-        GIT_COMMITTER_EMAIL=committer_email,
-        GIT_AUTHOR_NAME=author_name,
-        GIT_AUTHOR_EMAIL=author_email,
-    )
-    print(f"Configured git committer as '{committer_name} <{committer_email}>'")
-    print(f"Configured git author as '{author_name} <{author_email}>'")
-
-
-# Get required environment variables
-github_token = os.environ["GITHUB_TOKEN"]
-# Get environment variables with defaults
-path = os.getenv("CPR_PATH", os.getcwd())
-branch = os.getenv("CPR_BRANCH", DEFAULT_BRANCH)
-commit_message = os.getenv("CPR_COMMIT_MESSAGE", DEFAULT_COMMIT_MESSAGE)
-# Get environment variables with a default of 'None'
-committer = os.environ.get("CPR_COMMITTER")
-author = os.environ.get("CPR_AUTHOR")
-base = os.environ.get("CPR_BASE")
-
-# Set the repo path
-repo = Repo(path)
-
-# Determine the GitHub repository from git config
-# This will be the target repository for the pull request
-repo_url, protocol, github_repository = get_repository_detail()
-print(f"Target repository set to {github_repository}")
-
-# Determine if the checked out ref is a valid base for a pull request
-# The action needs the checked out HEAD ref to be a branch
-# This check will fail in the following cases:
-# - HEAD is detached
-# - HEAD is a merge commit (pull_request events)
-# - HEAD is a tag
-try:
-    working_base = repo.git.symbolic_ref("HEAD", "--short")
-except GitCommandError as e:
-    print(f"::debug::{e.stderr}")
-    print(
-        f"::error::The checked out ref is not a valid base for a pull request. "
-        + "Unable to continue. Exiting."
-    )
-    sys.exit(1)
-
-# Exit if the working base is a PR branch created by this action.
-# This may occur when using a PAT instead of GITHUB_TOKEN because
-# a PAT allows workflow actions to trigger further events.
-if working_base.startswith(branch):
-    print(
-        f"::error::Working base branch '{working_base}' was created by this action. "
-        + "Unable to continue. Exiting."
-    )
-    sys.exit(1)
-
-# Fetch an optional environment variable to determine the branch suffix
-branch_suffix = os.environ.get("CPR_BRANCH_SUFFIX")
-if branch_suffix is not None:
-    if branch_suffix == "short-commit-hash":
-        # Suffix with the short SHA1 hash
-        branch = "{}-{}".format(branch, repo.git.rev_parse("--short", "HEAD"))
-    elif branch_suffix == "timestamp":
-        # Suffix with the current timestamp
-        branch = "{}-{}".format(branch, int(time.time()))
-    elif branch_suffix == "random":
-        # Suffix with a 7 character random string
-        branch = "{}-{}".format(branch, cmn.get_random_string())
-    else:
-        print(
-            f"::error::Branch suffix '{branch_suffix}' is not a valid value. "
-            + "Unable to continue. Exiting."
-        )
-        sys.exit(1)
-
-# Output head branch
-print(f"Pull request branch to create or update set to '{branch}'")
-
-# Set the committer and author
-try:
-    set_committer_author(repo, committer, author)
-except ValueError as e:
-    print(f"::error::{e} " + "Unable to continue. Exiting.")
-    sys.exit(1)
-
-# Set the auth token in the repo URL
-# This supports checkout@v1. From v2 the auth token is saved for further use.
-if protocol == "HTTPS":
-    repo_url = f"https://x-access-token:{github_token}@github.com/{github_repository}"
-
-# Create or update the pull request branch
-result = coub.create_or_update_branch(repo, repo_url, commit_message, base, branch)
-
-if result["action"] in ["created", "updated"]:
-    # The branch was created or updated
-    print(f"Pushing pull request branch to 'origin/{branch}'")
-    repo.git.push("--force", repo_url, f"HEAD:refs/heads/{branch}")
-
-    # Set the base. It would have been 'None' if not specified as an input
-    base = result["base"]
-
-    # If there is no longer a diff with the base delete the branch and exit
-    if not result["diff"]:
-        print(f"Branch '{branch}' no longer differs from base branch '{base}'")
-        print(f"Closing pull request and deleting branch '{branch}'")
-        repo.git.push("--delete", "--force", repo_url, f"refs/heads/{branch}")
-        sys.exit()
-
-    # Fetch optional environment variables with default values
-    title = os.getenv("CPR_TITLE", DEFAULT_TITLE)
-    body = os.getenv("CPR_BODY", DEFAULT_BODY)
-
-    # Create or update the pull request
-    coupr.create_or_update_pull_request(
-        github_token,
-        github_repository,
-        branch,
-        base,
-        title,
-        body,
-        os.environ.get("CPR_LABELS"),
-        os.environ.get("CPR_ASSIGNEES"),
-        os.environ.get("CPR_MILESTONE"),
-        os.environ.get("CPR_REVIEWERS"),
-        os.environ.get("CPR_TEAM_REVIEWERS"),
-        os.environ.get("CPR_PROJECT_NAME"),
-        os.environ.get("CPR_PROJECT_COLUMN_NAME"),
-    )

dist/src/requirements.txt

@@ -1,2 +0,0 @@
-GitPython==3.0.7
-PyGithub==1.46

dist/src/setup-python.js

@@ -1,52 +0,0 @@
-const core = require("@actions/core");
-const tc = require("@actions/tool-cache");
-const path = require("path");
-const semver = require("semver");
-
-/**
- * Setup for Python from the GitHub Actions tool cache
- * Converted from https://github.com/actions/setup-python
- *
- * @param {string} versionSpec version of Python
- * @param {string} arch architecture (x64|x32)
- */
-let setupPython = function(versionSpec, arch) {
-  return new Promise((resolve, reject) => {
-    const IS_WINDOWS = process.platform === "win32";
-
-    // Find the version of Python we want in the tool cache
-    const installDir = tc.find("Python", versionSpec, arch);
-    core.debug(`installDir: ${installDir}`);
-
-    // Set paths
-    core.exportVariable("pythonLocation", installDir);
-    core.addPath(installDir);
-    if (IS_WINDOWS) {
-      core.addPath(path.join(installDir, "Scripts"));
-    } else {
-      core.addPath(path.join(installDir, "bin"));
-    }
-
-    if (IS_WINDOWS) {
-      // Add --user directory
-      // `installDir` from tool cache should look like $AGENT_TOOLSDIRECTORY/Python/<semantic version>/x64/
-      // So if `findLocalTool` succeeded above, we must have a conformant `installDir`
-      const version = path.basename(path.dirname(installDir));
-      const major = semver.major(version);
-      const minor = semver.minor(version);
-
-      const userScriptsDir = path.join(
-        process.env["APPDATA"] || "",
-        "Python",
-        `Python${major}${minor}`,
-        "Scripts"
-      );
-      core.addPath(userScriptsDir);
-    }
-    // On Linux and macOS, pip will create the --user directory and add it to PATH as needed.
-
-    resolve();
-  });
-};
-
-module.exports = setupPython;

dist/src/test_common.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-""" Test Common """
-import common as cmn
-import pytest
-
-
-def test_get_random_string():
-    assert len(cmn.get_random_string()) == 7
-    assert len(cmn.get_random_string(length=20)) == 20
-
-
-def test_parse_github_repository_success():
-    protocol, repository = cmn.parse_github_repository(
-        "https://github.com/peter-evans/create-pull-request"
-    )
-    assert protocol == "HTTPS"
-    assert repository == "peter-evans/create-pull-request"
-
-    protocol, repository = cmn.parse_github_repository(
-        "git@github.com:peter-evans/create-pull-request.git"
-    )
-    assert protocol == "SSH"
-    assert repository == "peter-evans/create-pull-request"
-
-
-def test_parse_github_repository_failure():
-    url = "https://github.com/peter-evans"
-    with pytest.raises(ValueError) as e_info:
-        cmn.parse_github_repository(url)
-    assert (
-        e_info.value.args[0]
-        == f"The format of '{url}' is not a valid GitHub repository URL"
-    )
-
-
-def test_parse_display_name_email_success():
-    name, email = cmn.parse_display_name_email("abc def <abc@def.com>")
-    assert name == "abc def"
-    assert email == "abc@def.com"
-
-    name, email = cmn.parse_display_name_email(
-        "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"
-    )
-    assert name == "github-actions[bot]"
-    assert email == "41898282+github-actions[bot]@users.noreply.github.com"
-
-
-def test_parse_display_name_email_failure():
-    display_name_email = "abc@def.com"
-    with pytest.raises(ValueError) as e_info:
-        cmn.parse_display_name_email(display_name_email)
-    assert (
-        e_info.value.args[0]
-        == f"The format of '{display_name_email}' is not a valid email address with display name"
-    )
-
-    display_name_email = " < >"
-    with pytest.raises(ValueError) as e_info:
-        cmn.parse_display_name_email(display_name_email)
-    assert (
-        e_info.value.args[0]
-        == f"The format of '{display_name_email}' is not a valid email address with display name"
-    )

dist/src/test_create_or_update_branch.py

@@ -1,757 +0,0 @@
-#!/usr/bin/env python3
-""" Test Create or Update Branch """
-import create_or_update_branch as coub
-from git import Repo
-import os
-import pytest
-import sys
-import time
-
-
-# Set git repo
-REPO_PATH = os.getenv("COUB_REPO_PATH", os.getcwd())
-repo = Repo(REPO_PATH)
-
-# Set git environment
-author_name = "github-actions[bot]"
-author_email = "41898282+github-actions[bot]@users.noreply.github.com"
-committer_name = "GitHub"
-committer_email = "noreply@github.com"
-repo.git.update_environment(
-    GIT_AUTHOR_NAME=author_name,
-    GIT_AUTHOR_EMAIL=author_email,
-    GIT_COMMITTER_NAME=committer_name,
-    GIT_COMMITTER_EMAIL=committer_email,
-)
-
-REPO_URL = repo.git.config("--get", "remote.origin.url")
-
-TRACKED_FILE = "tracked-file.txt"
-UNTRACKED_FILE = "untracked-file.txt"
-
-DEFAULT_BRANCH = "tests/master"
-NOT_BASE_BRANCH = "tests/branch-that-is-not-the-base"
-NOT_EXIST_BRANCH = "tests/branch-that-does-not-exist"
-
-COMMIT_MESSAGE = "[create-pull-request] automated change"
-BRANCH = "tests/create-pull-request/patch"
-BASE = DEFAULT_BRANCH
-
-
-def create_tracked_change(content=None):
-    if content is None:
-        content = str(time.time())
-    # Create a tracked file change
-    with open(os.path.join(REPO_PATH, TRACKED_FILE), "w") as f:
-        f.write(content)
-    return content
-
-
-def create_untracked_change(content=None):
-    if content is None:
-        content = str(time.time())
-    # Create an untracked file change
-    with open(os.path.join(REPO_PATH, UNTRACKED_FILE), "w") as f:
-        f.write(content)
-    return content
-
-
-def get_tracked_content():
-    # Read the content of the tracked file
-    with open(os.path.join(REPO_PATH, TRACKED_FILE), "r") as f:
-        return f.read()
-
-
-def get_untracked_content():
-    # Read the content of the untracked file
-    with open(os.path.join(REPO_PATH, UNTRACKED_FILE), "r") as f:
-        return f.read()
-
-
-def create_changes(tracked_content=None, untracked_content=None):
-    tracked_content = create_tracked_change(tracked_content)
-    untracked_content = create_untracked_change(untracked_content)
-    return tracked_content, untracked_content
-
-
-def create_commits(number=2, final_tracked_content=None, final_untracked_content=None):
-    for i in range(number):
-        commit_number = i + 1
-        if commit_number == number:
-            tracked_content, untracked_content = create_changes(
-                final_tracked_content, final_untracked_content
-            )
-        else:
-            tracked_content, untracked_content = create_changes()
-        repo.git.add("-A")
-        repo.git.commit(m=f"Commit {commit_number}")
-    return tracked_content, untracked_content
-
-
-@pytest.fixture(scope="module", autouse=True)
-def before_after_all():
-    print("Before all tests")
-    # Check there are no local changes that might be
-    # destroyed by running these tests
-    assert not repo.is_dirty(untracked_files=True)
-
-    # Create a new default branch for the test run
-    repo.remotes.origin.fetch()
-    repo.git.checkout("master")
-    repo.git.checkout("HEAD", b=NOT_BASE_BRANCH)
-    create_tracked_change()
-    repo.git.add("-A")
-    repo.git.commit(m="This commit should not appear in pr branches")
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{NOT_BASE_BRANCH}")
-    # Create a new default branch for the test run
-    repo.git.checkout("master")
-    repo.git.checkout("HEAD", b=DEFAULT_BRANCH)
-    create_tracked_change()
-    repo.git.add("-A")
-    repo.git.commit(m="Add file to be a tracked file for tests")
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-
-    yield
-
-    print("After all tests")
-    repo.git.checkout("master")
-    # Delete the "not base branch" created for the test run
-    repo.git.branch("--delete", "--force", NOT_BASE_BRANCH)
-    repo.git.push("--delete", "--force", REPO_URL, f"refs/heads/{NOT_BASE_BRANCH}")
-    # Delete the default branch created for the test run
-    repo.git.branch("--delete", "--force", DEFAULT_BRANCH)
-    repo.git.push("--delete", "--force", REPO_URL, f"refs/heads/{DEFAULT_BRANCH}")
-
-
-def before_test():
-    print("Before test")
-    # Checkout the default branch
-    repo.git.checkout(DEFAULT_BRANCH)
-
-
-def after_test(delete_remote=True):
-    print("After test")
-    # Output git log
-    print(repo.git.log("-5", pretty="oneline"))
-    # Delete the pull request branch if it exists
-    repo.git.checkout(DEFAULT_BRANCH)
-    print(f"Deleting {BRANCH}")
-    for branch in repo.branches:
-        if branch.name == BRANCH:
-            repo.git.branch("--delete", "--force", BRANCH)
-            break
-    if delete_remote:
-        print(f"Deleting origin/{BRANCH}")
-        for ref in repo.remotes.origin.refs:
-            if ref.name == f"origin/{BRANCH}":
-                repo.git.push("--delete", "--force", REPO_URL, f"refs/heads/{BRANCH}")
-                repo.remotes.origin.fetch("--prune")
-                break
-
-
-@pytest.fixture(autouse=True)
-def before_after_tests():
-    before_test()
-    yield
-    after_test()
-
-
-# Tests if a branch exists and can be fetched
-def coub_fetch_successful():
-    assert coub.fetch_successful(repo, REPO_URL, NOT_BASE_BRANCH)
-    assert not coub.fetch_successful(repo, REPO_URL, NOT_EXIST_BRANCH)
-
-
-# Tests no changes resulting in no new branch being created
-def coub_no_changes_on_create():
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "none"
-
-
-# Tests create and update with a tracked file change
-def coub_tracked_changes():
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-
-
-# Tests create and update with an untracked file change
-def coub_untracked_changes():
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with identical changes
-# The pull request branch will not be updated
-def coub_identical_changes():
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create identical tracked and untracked file changes
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "none"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with commits on the base inbetween
-def coub_commits_on_base():
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and then an update with no changes
-# This effectively reverts the branch back to match the base and results in no diff
-def coub_changes_no_diff():
-    # Save the default branch tracked content
-    default_tracked_content = get_tracked_content()
-
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Running with no update effectively reverts the branch back to match the base
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == default_tracked_content
-
-
-# Tests create and update with commits on the base inbetween
-# The changes on base effectively revert the branch back to match the base and results in no diff
-def coub_commits_on_base_no_diff():
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    tracked_content, untracked_content = create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Create the same tracked and untracked file changes that were made to the base
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with commits on the working base (during the workflow)
-def coub_commits_on_working_base():
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with changes and commits on the working base (during the workflow)
-def coub_changes_and_commits_on_working_base():
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with changes and commits on the working base (during the workflow)
-# with commits on the base inbetween
-def coub_changes_and_commits_on_base_and_working_base():
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests no changes resulting in no new branch being created
-def coub_wbnb_no_changes_on_create():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "none"
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with a tracked file change
-def coub_wbnb_tracked_changes():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with an untracked file change
-def coub_wbnb_untracked_changes():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with identical changes
-# The pull request branch will not be updated
-def coub_wbnb_identical_changes():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create identical tracked and untracked file changes
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "none"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with commits on the base inbetween
-def coub_wbnb_commits_on_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and then an update with no changes
-# This effectively reverts the branch back to match the base and results in no diff
-def coub_wbnb_changes_no_diff():
-    # Save the default branch tracked content
-    default_tracked_content = get_tracked_content()
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Running with no update effectively reverts the branch back to match the base
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == default_tracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with commits on the base inbetween
-# The changes on base effectively revert the branch back to match the base and results in no diff
-# This scenario will cause cherrypick to fail due to an empty commit.
-# The commit is empty because the changes now exist on the base.
-def coub_wbnb_commits_on_base_no_diff():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    tracked_content, untracked_content = create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create the same tracked and untracked file changes that were made to the base
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with commits on the working base (during the workflow)
-def coub_wbnb_commits_on_working_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with changes and commits on the working base (during the workflow)
-def coub_wbnb_changes_and_commits_on_working_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with changes and commits on the working base (during the workflow)
-# with commits on the base inbetween
-def coub_wbnb_changes_and_commits_on_base_and_working_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# pytest -v -s ~/git/create-pull-request/src
-
-test_coub_fetch_successful = coub_fetch_successful
-
-test_coub_no_changes_on_create = coub_no_changes_on_create
-test_coub_tracked_changes = coub_tracked_changes
-test_coub_untracked_changes = coub_untracked_changes
-test_coub_identical_changes = coub_identical_changes
-test_coub_commits_on_base = coub_commits_on_base
-
-test_coub_changes_no_diff = coub_changes_no_diff
-test_coub_commits_on_base_no_diff = coub_commits_on_base_no_diff
-
-test_coub_commits_on_working_base = coub_commits_on_working_base
-test_coub_changes_and_commits_on_working_base = coub_changes_and_commits_on_working_base
-test_coub_changes_and_commits_on_base_and_working_base = (
-    coub_changes_and_commits_on_base_and_working_base
-)
-
-# WBNB
-test_coub_wbnb_no_changes_on_create = coub_wbnb_no_changes_on_create
-test_coub_wbnb_tracked_changes = coub_wbnb_tracked_changes
-test_coub_wbnb_untracked_changes = coub_wbnb_untracked_changes
-test_coub_wbnb_identical_changes = coub_wbnb_identical_changes
-test_coub_wbnb_commits_on_base = coub_wbnb_commits_on_base
-
-test_coub_wbnb_changes_no_diff = coub_wbnb_changes_no_diff
-test_coub_wbnb_commits_on_base_no_diff = coub_wbnb_commits_on_base_no_diff
-
-test_coub_wbnb_commits_on_working_base = coub_wbnb_commits_on_working_base
-test_coub_wbnb_changes_and_commits_on_working_base = (
-    coub_wbnb_changes_and_commits_on_working_base
-)
-test_coub_wbnb_changes_and_commits_on_base_and_working_base = (
-    coub_wbnb_changes_and_commits_on_base_and_working_base
-)

docs/assets/cpr-gitgraph.htm

@@ -29,37 +29,37 @@
             orientation: "vertical-reverse"
         });
 
-        const master = gitgraph.branch("master");
-        master.commit("Last commit on base");
-        const localMaster = gitgraph.branch("<#1> master (local)");
-        localMaster.commit({
-            subject: "<uncommited changes>",
-            body: "Changes made to the local base during the workflow",
+        const main = gitgraph.branch("main");
+        main.commit("Last commit on base");
+        const localMain = gitgraph.branch("<#1> main (local)");
+        localMain.commit({
+            subject: "<uncommitted changes>",
+            body: "Changes to the local base during the workflow",
         })
         const remotePatch = gitgraph.branch("create-pull-request/patch");
         remotePatch.merge({
-            branch: localMaster,
+            branch: localMain,
             commitOptions: {
                 subject: "[create-pull-request] automated change",
                 body: "Changes pushed to create the remote branch",
             },
         });
-        master.commit("New commit on base");
+        main.commit("New commit on base");
 
-        const localMaster2 = gitgraph.branch("<#2> master (local)");
-        localMaster2.commit({
-            subject: "<uncommited changes>",
-            body: "Changes made to the updated local base during the workflow",
+        const localMain2 = gitgraph.branch("<#2> main (local)");
+        localMain2.commit({
+            subject: "<uncommitted changes>",
+            body: "Changes to the updated local base during the workflow",
         })
         remotePatch.merge({
-            branch: localMaster2,
+            branch: localMain2,
             commitOptions: {
                 subject: "[create-pull-request] automated change",
                 body: "Changes force pushed to update the remote branch",
             },
         });
 
-        master.merge(remotePatch);
+        main.merge(remotePatch);
 
     </script>
 

docs/concepts-guidelines.md

@@ -7,18 +7,21 @@ This document covers terminology, how the action works, general usage guidelines
 - [How the action works](#how-the-action-works)
 - [Guidelines](#guidelines)
   - [Providing a consistent base](#providing-a-consistent-base)
-  - [Pull request events](#pull-request-events)
-  - [Restrictions on forked repositories](#restrictions-on-forked-repositories)
+  - [Events which checkout a commit](#events-which-checkout-a-commit)
+  - [Restrictions on repository forks](#restrictions-on-repository-forks)
+  - [Triggering further workflow runs](#triggering-further-workflow-runs)
   - [Security](#security)
 - [Advanced usage](#advanced-usage)
   - [Creating pull requests in a remote repository](#creating-pull-requests-in-a-remote-repository)
   - [Push using SSH (deploy keys)](#push-using-ssh-deploy-keys)
-  - [Using in an alpine linux container](#using-in-an-alpine-linux-container)
-  - [Creating pull requests on tag push](#creating-pull-requests-on-tag-push)
+  - [Push pull request branches to a fork](#push-pull-request-branches-to-a-fork)
+  - [Authenticating with GitHub App generated tokens](#authenticating-with-github-app-generated-tokens)
+  - [GPG commit signature verification](#gpg-commit-signature-verification)
+  - [Running in a container or on self-hosted runners](#running-in-a-container-or-on-self-hosted-runners)
 
 ## Terminology
 
-[Pull requests](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests#about-pull-requests) are proposed changes to a repository branch that can be reviewed by a repository's collaborators before being accepted or rejected. 
+[Pull requests](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests#about-pull-requests) are proposed changes to a repository branch that can be reviewed by a repository's collaborators before being accepted or rejected. 
 
 A pull request references two branches:
 
@@ -27,9 +30,8 @@ A pull request references two branches:
 
 ## Events and checkout
 
-For each [event type](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/events-that-trigger-workflows) there is a default `GITHUB_SHA` that will be checked out by the GitHub Actions [checkout](https://github.com/actions/checkout) action.
-
-The majority of events will default to checking out the "last commit on default branch," which in most cases will be the latest commit on `master`.
+This action expects repositories to be checked out with the official GitHub Actions [checkout](https://github.com/actions/checkout) action.
+For each [event type](https://docs.github.com/en/actions/reference/events-that-trigger-workflows) there is a default `GITHUB_SHA` that will be checked out.
 
 The default can be overridden by specifying a `ref` on checkout.
 
@@ -41,7 +43,7 @@ The default can be overridden by specifying a `ref` on checkout.
 
 ## How the action works
 
-By default, the action expects to be executed on the pull request `base`—the branch you intend to modify with the proposed changes.
+Unless the `base` input is supplied, the action expects the target repository to be checked out on the pull request `base`—the branch you intend to modify with the proposed changes.
 
 Workflow steps:
 
@@ -57,11 +59,11 @@ The following git diagram shows how the action creates and updates a pull reques
 
 ### Providing a consistent base
 
-For the action to work correctly it should be executed in a workflow that checks out a *consistent base* branch. This will be the base of the pull request unless overridden with the `base` input.
+For the action to work correctly it should be executed in a workflow that checks out a *consistent* base branch. This will be the base of the pull request unless overridden with the `base` input.
 
 This means your workflow should be consistently checking out the branch that you intend to modify once the PR is merged.
 
-In the following example, the [`push`](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/events-that-trigger-workflows#push-event-push) and [`create`](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/events-that-trigger-workflows#create-event-create) events both trigger the same workflow. This will cause the checkout action to checkout commits from inconsistent branches. Do *not* do this. It will cause multiple pull requests to be created for each additional `base` the action is executed against.
+In the following example, the [`push`](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#push) and [`create`](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#create) events both trigger the same workflow. This will cause the checkout action to checkout inconsistent branches and commits. Do *not* do this. It will cause multiple pull requests to be created for each additional `base` the action is executed against.
 
 ```yml
 on:
@@ -74,32 +76,48 @@ jobs:
       - uses: actions/checkout@v2
 ```
 
-Although rare, there may be use cases where it makes sense to execute the workflow on a branch that is not the base of the pull request. In these cases, the base branch can be specified with the `base` action input. The action will attempt to rebase changes made during the workflow on to the actual base.
+There may be use cases where it makes sense to execute the workflow on a branch that is not the base of the pull request. In these cases, the base branch can be specified with the `base` action input. The action will attempt to rebase changes made during the workflow on to the actual base.
 
-### Pull request events
+### Events which checkout a commit
 
-Workflows triggered by `pull_request` events will by default check out a [merge commit](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/events-that-trigger-workflows#pull-request-event-pull_request). To prevent the merge commit being included in created pull requests it is necessary to checkout the `head_ref`.
+The [default checkout](#events-and-checkout) for the majority of events will leave the repository checked out on a branch.
+However, some events such as `release` and `pull_request` will leave the repository in a "detached HEAD" state.
+This is because they checkout a commit, not a branch.
+In these cases, you *must supply* the `base` input so the action can rebase changes made during the workflow for the pull request.
+
+Workflows triggered by [`pull_request`](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#pull_request) events will by default check out a merge commit. Set the `base` input as follows to base the new pull request on the current pull request's branch.
 
 ```yml
-      - uses: actions/checkout@v2
+      - uses: peter-evans/create-pull-request@v3
         with:
-          ref: ${{ github.head_ref }}
+          base: ${{ github.head_ref }}
 ```
 
-### Restrictions on forked repositories
+Workflows triggered by [`release`](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#release) events will by default check out a tag. For most use cases, you will need to set the `base` input to the branch name of the tagged commit.
 
-GitHub Actions have imposed restrictions on events triggered by a forked repository. For example, the `pull_request` event triggered by a fork opening a pull request in the upstream repository.
+```yml
+      - uses: peter-evans/create-pull-request@v3
+        with:
+          base: main
+```
 
-- Events from forks cannot access secrets, except for for the default `GITHUB_TOKEN`.
+### Restrictions on repository forks
+
+GitHub Actions have imposed restrictions on workflow runs triggered by public repository forks.
+Private repositories can be configured to [enable workflows](https://docs.github.com/en/github/administering-a-repository/disabling-or-limiting-github-actions-for-a-repository#enabling-workflows-for-private-repository-forks) from forks to run without restriction.
+
+The restrictions apply to the `pull_request` event triggered by a fork opening a pull request in the upstream repository.
+
+- Events from forks cannot access secrets, except for the default `GITHUB_TOKEN`.
     > With the exception of GITHUB_TOKEN, secrets are not passed to the runner when a workflow is triggered from a forked repository.
 
-    [GitHub Actions: Using encrypted secrets in a workflow](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/creating-and-using-encrypted-secrets#using-encrypted-secrets-in-a-workflow)
+    [GitHub Actions: Using encrypted secrets in a workflow](https://docs.github.com/en/actions/configuring-and-managing-workflows/creating-and-storing-encrypted-secrets#using-encrypted-secrets-in-a-workflow)
 
 - The `GITHUB_TOKEN` has read-only access when an event is triggered by a forked repository.
 
-   [GitHub Actions: Permissions for the GITHUB_TOKEN](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/authenticating-with-the-github_token#permissions-for-the-github_token)
+   [GitHub Actions: Permissions for the GITHUB_TOKEN](https://docs.github.com/en/actions/configuring-and-managing-workflows/authenticating-with-the-github_token#permissions-for-the-github_token)
 
-These restrictions mean that during a `pull_request` event triggered by a forked repository the action will be unable to commit changes to a branch.
+These restrictions mean that during a `pull_request` event triggered by a forked repository, actions have no write access to GitHub resources and will fail on any attempt.
 
 A job condition can be added to prevent workflows from executing when triggered by a repository fork.
 
@@ -112,31 +130,47 @@ jobs:
     if: github.event.pull_request.head.repo.full_name == github.repository
 ```
 
+For further reading regarding the security of pull requests, see this GitHub blog post titled [Keeping your GitHub Actions and workflows secure: Preventing pwn requests](https://securitylab.github.com/research/github-actions-preventing-pwn-requests/)
+
+### Triggering further workflow runs
+
+Pull requests created by the action using the default `GITHUB_TOKEN` cannot trigger other workflows. If you have `on: pull_request` or `on: push` workflows acting as checks on pull requests, they will not run.
+
+> When you use the repository's GITHUB_TOKEN to perform tasks on behalf of the GitHub Actions app, events triggered by the GITHUB_TOKEN will not create a new workflow run.
+
+[GitHub Actions: Events that trigger workflows](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#triggering-new-workflows-using-a-personal-access-token)
+
+#### Workarounds to trigger further workflow runs
+
+There are a number of workarounds with different pros and cons.
+
+- Use the default `GITHUB_TOKEN` and allow the action to create pull requests that have no checks enabled. Manually close pull requests and immediately reopen them. This will enable `on: pull_request` workflows to run and be added as checks.
+
+- Use a `repo` scoped [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) created on an account that has write access to the repository that pull requests are being created in. This is the standard workaround and [recommended by GitHub](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#triggering-new-workflows-using-a-personal-access-token). However, the PAT cannot be scoped to a specific repository so the token becomes a very sensitive secret. If this is a concern, the PAT can instead be created for a dedicated [machine account](https://docs.github.com/en/github/site-policy/github-terms-of-service#3-account-requirements) that has collaborator access to the repository. Also note that because the account that owns the PAT will be the creator of pull requests, that user account will be unable to perform actions such as request changes or approve the pull request.
+
+- Use [SSH (deploy keys)](#push-using-ssh-deploy-keys) to push the pull request branch. This is arguably more secure than using a PAT because deploy keys can be set per repository. However, this method will only trigger `on: push` workflows.
+
+- Use a [machine account that creates pull requests from its own fork](#push-pull-request-branches-to-a-fork). This is the most secure because the PAT created only grants access to the machine account's fork, not the main repository. This method will trigger `on: pull_request` workflows to run. Workflows triggered `on: push` will not run because the push event is in the fork.
+
+- Use a [GitHub App to generate a token](#authenticating-with-github-app-generated-tokens) that can be used with this action. GitHub App generated tokens are more secure than using a PAT because GitHub App access permissions can be set with finer granularity and are scoped to only repositories where the App is installed. This method will trigger both `on: push` and `on: pull_request` workflows.
+
 ### Security
 
 From a security perspective it's good practice to fork third-party actions, review the code, and use your fork of the action in workflows.
 By using third-party actions directly the risk exists that it could be modified to do something malicious, such as capturing secrets.
 
-This action uses [ncc](https://github.com/zeit/ncc) to compile the Node.js code and dependencies into a single file.
-Python dependencies are vendored and committed to the repository [here](https://github.com/peter-evans/create-pull-request/tree/master/dist/vendor).
-No dependencies are downloaded during the action execution.
-
-Vendored Python dependencies can be reviewed by rebuilding the [dist](https://github.com/peter-evans/create-pull-request/tree/master/dist) directory and redownloading dependencies.
-The following commands require Node and Python 3.
-
-```
-npm install
-npm run clean
-npm run package
+Alternatively, use the action directly and reference the commit hash for the version you want to target.
+```yml
+  - uses: thirdparty/foo-action@172ec762f2ac8e050062398456fccd30444f8f30
 ```
 
-The `dist` directory should be rebuilt leaving no git diff.
+This action uses [ncc](https://github.com/vercel/ncc) to compile the Node.js code and dependencies into a single JavaScript file under the [dist](https://github.com/peter-evans/create-pull-request/tree/main/dist) directory.
 
 ## Advanced usage
 
 ### Creating pull requests in a remote repository
 
-Checking out a branch from a different repository from where the workflow is executing will make *that repository* the target for the created pull request. In this case, a `repo` scoped [Personal Access Token (PAT)](https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line) is required.
+Checking out a branch from a different repository from where the workflow is executing will make *that repository* the target for the created pull request. In this case, a `repo` scoped [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) is required.
 
 ```yml
       - uses: actions/checkout@v2
@@ -146,46 +180,154 @@ Checking out a branch from a different repository from where the workflow is exe
 
       # Make changes to pull request here
 
-      - uses: peter-evans/create-pull-request@v2
+      - uses: peter-evans/create-pull-request@v3
         with:
           token: ${{ secrets.PAT }}
 ```
 
 ### Push using SSH (deploy keys)
 
-[Deploy keys](https://developer.github.com/v3/guides/managing-deploy-keys/#deploy-keys) can be set per repository and so are arguably more secure than using a `repo` scoped [Personal Access Token (PAT)](https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line).
+[Deploy keys](https://developer.github.com/v3/guides/managing-deploy-keys/#deploy-keys) can be set per repository and so are arguably more secure than using a `repo` scoped [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token).
 Allowing the action to push with a configured deploy key will trigger `on: push` workflows. This makes it an alternative to using a PAT to trigger checks for pull requests.
+Note that you cannot use deploy keys alone to [create a pull request in a remote repository](#creating-pull-requests-in-a-remote-repository) because then using a PAT would become a requirement. This method only makes sense if creating a pull request in the repository where the workflow is running.
 
 How to use SSH (deploy keys) with create-pull-request action:
 
-1. [Create an new SSH key pair](https://help.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent#generating-a-new-ssh-key) for your repository. Do not set a passphrase.
+1. [Create a new SSH key pair](https://docs.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent#generating-a-new-ssh-key) for your repository. Do not set a passphrase.
 2. Copy the contents of the public key (.pub file) to a new repository [deploy key](https://developer.github.com/v3/guides/managing-deploy-keys/#deploy-keys) and check the box to "Allow write access."
 3. Add a secret to the repository containing the entire contents of the private key.
-4. As shown in the example steps below, use the [`webfactory/ssh-agent`](https://github.com/webfactory/ssh-agent) action to install the private key and clone your repository. Remember to checkout the `base` of your pull request if it's not the default branch, e.g. `git checkout my-branch`.
+4. As shown in the example below, configure `actions/checkout` to use the deploy key you have created.
 
 ```yml
     steps:
-      - uses: webfactory/ssh-agent@v0.2.0
+      - uses: actions/checkout@v2
         with:
-          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
-
-      - name: Checkout via SSH
-        run: git clone git@github.com:peter-evans/create-pull-request.git .
+          ssh-key: ${{ secrets.SSH_PRIVATE_KEY }}
 
       # Make changes to pull request here
 
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+        uses: peter-evans/create-pull-request@v3
 ```
 
-### Using in an alpine linux container
+### Push pull request branches to a fork
 
-This action can be run inside an Alpine Linux container by pre-installing the correct binaries for the action's dependencies.
+Instead of pushing pull request branches to the repository you want to update, you can push them to a fork of that repository.
+This allows you to employ the [principle of least privilege](https://en.wikipedia.org/wiki/Principle_of_least_privilege) by using a dedicated user acting as a [machine account](https://docs.github.com/en/github/site-policy/github-terms-of-service#3-account-requirements).
+This user has no access to the main repository.
+It will use their own fork to push code and create the pull request.
 
-The following example workflow installs git and Python dependencies at the start of the job. You can also bake these dependencies into your own Alpine Docker image if you prefer. Note that git must be installed *before* running `actions/checkout`, otherwise it will just download the source of the repository instead of cloning it.
+1. Create a new GitHub user and login.
+2. Fork the repository that you will be creating pull requests in.
+3. Create a [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token).
+4. Logout and log back into your main user account.
+5. Add a secret to your repository containing the above PAT.
+6. As shown in the following example workflow, set the `push-to-fork` input to the full repository name of the fork.
 
+```yaml
+      - uses: actions/checkout@v2
+
+      # Make changes to pull request here
+
+      - uses: peter-evans/create-pull-request@v3
+        with:
+          token: ${{ secrets.MACHINE_USER_PAT }}
+          push-to-fork: machine-user/fork-of-repository
+```
+
+### Authenticating with GitHub App generated tokens
+
+A GitHub App can be created for the sole purpose of generating tokens for use with GitHub actions.
+These tokens can be used in place of `GITHUB_TOKEN` or a [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token).
+GitHub App generated tokens are more secure than using a PAT because GitHub App access permissions can be set with finer granularity and are scoped to only repositories where the App is installed.
+
+1. Create a minimal [GitHub App](https://docs.github.com/en/developers/apps/creating-a-github-app), setting the following fields:
+
+    - Set `GitHub App name`.
+    - Set `Homepage URL` to anything you like, such as your GitHub profile page.
+    - Uncheck `Active` under `Webhook`. You do not need to enter a `Webhook URL`.
+    - Under `Repository permissions: Contents` select `Access: Read & write`.
+    - Under `Repository permissions: Pull requests` select `Access: Read & write`.
+    - Under `Organization permissions: Members` select `Access: Read-only`.
+      - **NOTE**: Only needed if you would like add teams as reviewers to PRs.
+
+2. Create a Private key from the App settings page and store it securely.
+
+3. Install the App on any repository where workflows will run requiring tokens.
+
+4. Set secrets on your repository containing the GitHub App ID, and the private key you created in step 2. e.g. `APP_ID`, `APP_PRIVATE_KEY`.
+
+5. The following example workflow shows how to use [tibdex/github-app-token](https://github.com/tibdex/github-app-token) to generate a token for use with this action.
+
+```yaml
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: tibdex/github-app-token@v1
+        id: generate-token
+        with:
+          app_id: ${{ secrets.APP_ID }}
+          private_key: ${{ secrets.APP_PRIVATE_KEY }}
+
+      # Make changes to pull request here
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+```
+
+### GPG commit signature verification
+
+The action can use GPG to sign commits with a GPG key that you generate yourself.
+
+1. Follow GitHub's guide to [generate a new GPG key](https://docs.github.com/en/github/authenticating-to-github/generating-a-new-gpg-key).
+
+2. [Add the public key](https://docs.github.com/en/github/authenticating-to-github/adding-a-new-gpg-key-to-your-github-account) to the user account associated with the [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) that you will use with the action.
+
+3. Copy the private key to your clipboard, replacing `email@example.com` with the email address of your GPG key.
+   ```
+   # macOS
+   gpg --armor --export-secret-key email@example.com | pbcopy
+   ```
+
+4. Paste the private key into a repository secret where the workflow will run. e.g. `GPG_PRIVATE_KEY`
+
+5. Create another repository secret for the key's passphrase, if applicable. e.g. `GPG_PASSPHRASE`
+
+6. The following example workflow shows how to use [crazy-max/ghaction-import-gpg](https://github.com/crazy-max/ghaction-import-gpg) to import your GPG key and allow the action to sign commits.
+
+   Note that the `committer` email address *MUST* match the email address used to create your GPG key.
+
+```yaml
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: crazy-max/ghaction-import-gpg@v3
+        with:
+          gpg-private-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          passphrase: ${{ secrets.GPG_PASSPHRASE }}
+          git-user-signingkey: true
+          git-commit-gpgsign: true
+
+      # Make changes to pull request here
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          token: ${{ secrets.PAT }}
+          committer: example <email@example.com>
+```
+
+### Running in a container or on self-hosted runners
+
+This action can be run inside a container, or on [self-hosted runners](https://docs.github.com/en/actions/hosting-your-own-runners), by installing the necessary dependencies.
+
+This action requires `git` to be installed and on the `PATH`. Note that `actions/checkout` requires Git 2.18 or higher to be installed, otherwise it will just download the source of the repository instead of cloning it.
+
+The following examples of running in a container show the dependencies being installed during the workflow, but they could also be pre-installed in a custom image.
+
+**Alpine container example:**
 ```yml
 jobs:
   createPullRequestAlpine:
@@ -194,80 +336,35 @@ jobs:
       image: alpine
     steps:
       - name: Install dependencies
-        run: |
-          apk --no-cache add git python3
-          ln -sf python3 /usr/bin/python
-          ln -sf pip3 /usr/bin/pip
+        run: apk --no-cache add git
 
       - uses: actions/checkout@v2
 
       # Make changes to pull request here
 
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+        uses: peter-evans/create-pull-request@v3
 ```
 
-### Creating pull requests on tag push
-
-An `on: push` workflow will also trigger when tags are pushed.
-During these events, the `actions/checkout` action will check out the `ref/tags/<tag>` git ref by default.
-This means the repository will *not* be checked out on an active branch.
-
-If you would like to run `create-pull-request` action on the tagged commit you can achieve this by creating a temporary branch as follows.
-
+**Ubuntu container example:**
 ```yml
-on:
-  push:
-    tags:
-      - 'v*.*.*'
 jobs:
-  example:
+  createPullRequestAlpine:
     runs-on: ubuntu-latest
+    container:
+      image: ubuntu
     steps:
-      - uses: actions/checkout@v2
-
-      - name: Create a temporary tag branch
+      - name: Install dependencies
         run: |
-          git config --global user.name 'GitHub'
-          git config --global user.email 'noreply@github.com'
-          git checkout -b temp-${GITHUB_REF:10}
-          git push --set-upstream origin temp-${GITHUB_REF:10}
+          apt-get update
+          apt-get install -y software-properties-common
+          add-apt-repository -y ppa:git-core/ppa
+          apt-get install -y git
+
+      - uses: actions/checkout@v2
 
       # Make changes to pull request here
 
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          base: master
-
-      - name: Delete tag branch
-        run: |
-          git push --delete origin temp-${GITHUB_REF:10}
-```
-
-This is an alternative, simpler workflow to the one above. However, this is not guaranteed to checkout the tagged commit.
-There is a chance that in between the tag being pushed and checking out the `master` branch in the workflow, another commit is made to `master`. If that possibility is not a concern, this workflow will work fine.
-
-```yml
-on:
-  push:
-    tags:
-      - 'v*.*.*'
-jobs:
-  example:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          ref: master
-
-      # Make changes to pull request here
-
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+        uses: peter-evans/create-pull-request@v3
 ```

docs/examples.md

@@ -3,9 +3,14 @@
 - [Use case: Create a pull request to update X on push](#use-case-create-a-pull-request-to-update-x-on-push)
   - [Update project authors](#update-project-authors)
   - [Keep a branch up-to-date with another](#keep-a-branch-up-to-date-with-another)
+- [Use case: Create a pull request to update X on release](#use-case-create-a-pull-request-to-update-x-on-release)
+  - [Update changelog](#update-changelog)
 - [Use case: Create a pull request to update X periodically](#use-case-create-a-pull-request-to-update-x-periodically)
   - [Update NPM dependencies](#update-npm-dependencies)
+  - [Update Gradle dependencies](#update-gradle-dependencies)
+  - [Update Cargo dependencies](#update-cargo-dependencies)
   - [Update SwaggerUI for GitHub Pages](#update-swaggerui-for-github-pages)
+  - [Keep a fork up-to-date with its upstream](#keep-a-fork-up-to-date-with-its-upstream)
   - [Spider and download a website](#spider-and-download-a-website)
 - [Use case: Create a pull request to update X by calling the GitHub API](#use-case-create-a-pull-request-to-update-x-by-calling-the-github-api)
   - [Call the GitHub API from an external service](#call-the-github-api-from-an-external-service)
@@ -15,6 +20,8 @@
 - [Misc workflow tips](#misc-workflow-tips)
   - [Filtering push events](#filtering-push-events)
   - [Dynamic configuration using variables](#dynamic-configuration-using-variables)
+  - [Setting the pull request body from a file](#setting-the-pull-request-body-from-a-file)
+  - [Using a markdown template](#using-a-markdown-template)
   - [Debugging GitHub Actions](#debugging-github-actions)
 
 
@@ -31,7 +38,7 @@ name: Update AUTHORS
 on:
   push:
     branches:
-      - master
+      - main
 jobs:
   updateAuthors:
     runs-on: ubuntu-latest
@@ -43,9 +50,8 @@ jobs:
         run: |
           git log --format='%aN <%aE>%n%cN <%cE>' | sort -u > AUTHORS
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           commit-message: update authors
           title: Update AUTHORS
           body: Credit new contributors by updating AUTHORS
@@ -56,14 +62,14 @@ jobs:
 
 This is a use case where a branch should be kept up to date with another by opening a pull request to update it. The pull request should then be updated with new changes until it is merged or closed.
 
-In this example scenario, a branch called `production` should be updated via pull request to keep it in sync with `master`. Merging the pull request is effectively promoting those changes to production.
+In this example scenario, a branch called `production` should be updated via pull request to keep it in sync with `main`. Merging the pull request is effectively promoting those changes to production.
 
 ```yml
 name: Create production promotion pull request
 on:
   push:
     branches:
-      - master
+      - main
 jobs:
   productionPromotion:
     runs-on: ubuntu-latest
@@ -73,48 +79,188 @@ jobs:
           ref: production
       - name: Reset promotion branch
         run: |
-          git fetch origin master:master
-          git reset --hard master
+          git fetch origin main:main
+          git reset --hard main
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           branch: production-promotion
 ```
 
+## Use case: Create a pull request to update X on release
+
+This pattern will work well for updating any kind of static content based on the tagged commit of a release. Note that because `release` is one of the [events which checkout a commit](concepts-guidelines.md#events-which-checkout-a-commit) it is necessary to supply the `base` input to the action.
+
+### Update changelog
+
+Raises a pull request to update the `CHANGELOG.md` file based on the tagged commit of the release.
+Note that [git-chglog](https://github.com/git-chglog/git-chglog/) requires some configuration files to exist in the repository before this workflow will work.
+
+This workflow assumes the tagged release was made on a default branch called `main`.
+
+```yml
+name: Update Changelog
+on:
+  release:
+    types: [published]
+jobs:
+  updateChangelog:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: Update Changelog
+        run: |
+          curl -o git-chglog -L https://github.com/git-chglog/git-chglog/releases/download/0.9.1/git-chglog_linux_amd64
+          chmod u+x git-chglog
+          ./git-chglog -o CHANGELOG.md
+          rm git-chglog
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          commit-message: update changelog
+          title: Update Changelog
+          body: Update changelog to reflect release changes
+          branch: update-changelog
+          base: main
+```
+
 ## Use case: Create a pull request to update X periodically
 
 This pattern will work well for updating any kind of static content from an external source. The workflow executes on a schedule and raises a pull request when there are changes.
 
 ### Update NPM dependencies
 
+This workflow will create a pull request for npm dependencies.
+It works best in combination with a build workflow triggered on `push` and `pull_request`.
+A [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) can be used in order for the creation of the pull request to trigger further workflows. See the [documentation here](concepts-guidelines.md#triggering-further-workflow-runs) for further details.
+
 ```yml
 name: Update Dependencies
 on:
   schedule:
     - cron:  '0 10 * * 1'
 jobs:
-  update-deps:
+  update-dep:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
         with:
-          node-version: '10.x'
+          node-version: '12.x'
       - name: Update dependencies
-        id: vars
         run: |
-          npm install -g npm-check-updates
-          ncu -u
+          npx -p npm-check-updates ncu -u
           npm install
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: update dependencies
-          title: Automated Dependency Updates
-          body: This is an auto-generated PR with dependency updates.
-          branch: dep-updates
+            token: ${{ secrets.PAT }}
+            commit-message: Update dependencies
+            title: Update dependencies
+            body: |
+              - Dependency updates
+  
+              Auto-generated by [create-pull-request][1]
+  
+              [1]: https://github.com/peter-evans/create-pull-request
+            branch: update-dependencies
+```
+
+The above workflow works best in combination with a build workflow triggered on `push` and `pull_request`.
+
+```yml
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12.x
+      - run: npm ci
+      - run: npm run test
+      - run: npm run build
+```
+
+### Update Gradle dependencies
+
+The following workflow will create a pull request for Gradle dependencies.
+It requires first configuring your project to use Gradle lockfiles.
+See [here](https://github.com/peter-evans/gradle-auto-dependency-updates) for how to configure your project and use the following workflow.
+
+```yml
+name: Update Dependencies
+on:
+  schedule:
+    - cron:  '0 1 * * 1'
+jobs:
+  update-dep:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+      - name: Perform dependency resolution and write new lockfiles
+        run: ./gradlew dependencies --write-locks
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+            token: ${{ secrets.PAT }}
+            commit-message: Update dependencies
+            title: Update dependencies
+            body: |
+              - Dependency updates
+  
+              Auto-generated by [create-pull-request][1]
+  
+              [1]: https://github.com/peter-evans/create-pull-request
+            branch: update-dependencies
+```
+
+### Update Cargo dependencies
+
+The following workflow will create a pull request for Cargo dependencies.
+It optionally uses [`cargo-edit`](https://github.com/killercup/cargo-edit) to update `Cargo.toml` and keep it in sync with `Cargo.lock`.
+
+```yml
+name: Update Dependencies
+on:
+  schedule:
+    - cron:  '0 1 * * 1'
+jobs:
+  update-dep:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Update dependencies
+        run: |
+          cargo install cargo-edit
+          cargo update
+          cargo upgrade --to-lockfile
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+            token: ${{ secrets.PAT }}
+            commit-message: Update dependencies
+            title: Update dependencies
+            body: |
+              - Dependency updates
+  
+              Auto-generated by [create-pull-request][1]
+  
+              [1]: https://github.com/peter-evans/create-pull-request
+            branch: update-dependencies
 ```
 
 ### Update SwaggerUI for GitHub Pages
@@ -159,9 +305,8 @@ jobs:
           # Update current release
           echo ${{ steps.swagger-ui.outputs.release_tag }} > swagger-ui.version
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           commit-message: Update swagger-ui to ${{ steps.swagger-ui.outputs.release_tag }}
           title: Update SwaggerUI to ${{ steps.swagger-ui.outputs.release_tag }}
           body: |
@@ -175,6 +320,41 @@ jobs:
           branch: swagger-ui-updates
 ```
 
+### Keep a fork up-to-date with its upstream
+
+This example is designed to be run in a seperate repository from the fork repository itself.
+The aim of this is to prevent committing anything to the fork's default branch would cause it to differ from the upstream.
+
+In the following example workflow, `owner/repo` is the upstream repository and `fork-owner/repo` is the fork. It assumes the default branch of the upstream repository is called `main`.
+
+The [Personal Access Token (PAT)](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token) should have `repo` scope. Additionally, if the upstream makes changes to the `.github/workflows` directory, the action will be unable to push the changes to a branch and throw the error "_(refusing to allow a GitHub App to create or update workflow `.github/workflows/xxx.yml` without `workflows` permission)_". To allow these changes to be pushed to the fork, add the `workflow` scope to the PAT. Of course, allowing this comes with the risk that the workflow changes from the upstream could run and do something unexpected. Disabling GitHub Actions in the fork is highly recommended to prevent this.
+
+When you merge the pull request make sure to choose the [`Rebase and merge`](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-request-merges#rebase-and-merge-your-pull-request-commits) option. This will make the fork's commits match the commits on the upstream.
+
+```yml
+name: Update fork
+on:
+  schedule:
+    - cron:  '0 0 * * 0'
+jobs:
+  updateFork:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          repository: fork-owner/repo
+      - name: Reset the default branch with upstream changes
+        run: |
+          git remote add upstream https://github.com/owner/repo.git
+          git fetch upstream main:upstream-main
+          git reset --hard upstream-main
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          token: ${{ secrets.PAT }}
+          branch: upstream-changes
+```
+
 ### Spider and download a website
 
 This workflow spiders a website and downloads the content. Any changes to the website will be raised in a pull request.
@@ -202,9 +382,8 @@ jobs:
             --domains quotes.toscrape.com \
             http://quotes.toscrape.com/
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           commit-message: update local website copy
           title: Automated Updates to Local Website Copy
           body: This is an auto-generated PR with website updates.
@@ -213,7 +392,7 @@ jobs:
 
 ## Use case: Create a pull request to update X by calling the GitHub API
 
-You can use the GitHub API to trigger a webhook event called [`repository_dispatch`](https://help.github.com/en/github/automating-your-workflow-with-github-actions/events-that-trigger-workflows#external-events-repository_dispatch) when you want to trigger a workflow for activity that happens outside of GitHub.
+You can use the GitHub API to trigger a webhook event called [`repository_dispatch`](https://docs.github.com/en/actions/reference/events-that-trigger-workflows#repository_dispatch) when you want to trigger a workflow for any activity that happens outside of GitHub.
 This pattern will work well for updating any kind of static content from an external source.
 
 You can modify any of the examples in the previous section to work in this fashion.
@@ -231,7 +410,7 @@ on:
 An `on: repository_dispatch` workflow can be triggered by a call to the GitHub API as follows.
 
 - `[username]` is a GitHub username
-- `[token]` is a `repo` scoped [Personal Access Token](https://help.github.com/en/articles/creating-a-personal-access-token-for-the-command-line)
+- `[token]` is a `repo` scoped [Personal Access Token](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token)
 - `[repository]` is the name of the repository the workflow resides in.
 
 ```
@@ -248,7 +427,7 @@ An `on: repository_dispatch` workflow can be triggered from another workflow wit
 
 ```yml
 - name: Repository Dispatch
-  uses: peter-evans/repository-dispatch@v1.0.0
+  uses: peter-evans/repository-dispatch@v1
   with:
     token: ${{ secrets.REPO_ACCESS_TOKEN }}
     repository: username/my-repo
@@ -262,7 +441,8 @@ An `on: repository_dispatch` workflow can be triggered from another workflow wit
 
 This is a pattern that lends itself to automated code linting and fixing. A pull request can be created to fix or modify something during an `on: pull_request` workflow. The pull request containing the fix will be raised with the original pull request as the base. This can be then be merged to update the original pull request and pass any required tests.
 
-Note that due to [limitations on forked repositories](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/authenticating-with-the-github_token#permissions-for-the-github_token) workflows for this use case do not work for pull requests raised from forks.
+Note that due to [token restrictions on public repository forks](https://docs.github.com/en/actions/configuring-and-managing-workflows/authenticating-with-the-github_token#permissions-for-the-github_token), workflows for this use case do not work for pull requests raised from forks.
+Private repositories can be configured to [enable workflows](https://docs.github.com/en/github/administering-a-repository/disabling-or-limiting-github-actions-for-a-repository#enabling-workflows-for-private-repository-forks) from forks to run without restriction. 
 
 ### autopep8
 
@@ -297,9 +477,8 @@ jobs:
         run: echo ::set-output name=branch-name::"autopep8-patches/${{ github.head_ref }}"
       - name: Create Pull Request
         if: steps.autopep8.outputs.exit-code == 2
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           commit-message: autopep8 action fixes
           title: Fixes by autopep8 action
           body: This is an auto-generated PR with fixes by autopep8.
@@ -346,7 +525,7 @@ jobs:
 
 The following examples show how configuration for the action can be dynamically defined in a previous workflow step.
 
-The recommended method is to use [`set-output`](https://help.github.com/en/github/automating-your-workflow-with-github-actions/development-tools-for-github-actions#set-an-output-parameter-set-output). Note that the step where output variables are defined must have an id.
+The recommended method is to use [`set-output`](https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-output-parameter). Note that the step where output variables are defined must have an id.
 
 ```yml
       - name: Set output variables
@@ -356,39 +535,67 @@ The recommended method is to use [`set-output`](https://help.github.com/en/githu
           echo ::set-output name=pr_body::"This PR was auto-generated on $(date +%d-%m-%Y) \
             by [create-pull-request](https://github.com/peter-evans/create-pull-request)."
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
           title: ${{ steps.vars.outputs.pr_title }}
           body: ${{ steps.vars.outputs.pr_body }}
 ```
 
-Alternatively, [`set-env`](https://help.github.com/en/github/automating-your-workflow-with-github-actions/development-tools-for-github-actions#set-an-environment-variable-set-env) can be used to create environment variables.
+### Setting the pull request body from a file
+
+This example shows how file content can be read into a variable and passed to the action.
+The content must be [escaped to preserve newlines](https://github.community/t/set-output-truncates-multiline-strings/16852/3).
 
 ```yml
-      - name: Set environment variables
+      - id: get-pr-body
         run: |
-          echo ::set-env name=PULL_REQUEST_TITLE::"[Test] Add report file $(date +%d-%m-%Y)"
-          echo ::set-env name=PULL_REQUEST_BODY::"This PR was auto-generated on $(date +%d-%m-%Y) \
-            by [create-pull-request](https://github.com/peter-evans/create-pull-request)."
+          body=$(cat pr-body.txt)
+          body="${body//'%'/'%25'}"
+          body="${body//$'\n'/'%0A'}"
+          body="${body//$'\r'/'%0D'}" 
+          echo ::set-output name=body::$body
+
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          title: ${{ env.PULL_REQUEST_TITLE }}
-          body: ${{ env.PULL_REQUEST_BODY }}
+          body: ${{ steps.get-pr-body.outputs.body }}
+```
+
+### Using a markdown template
+
+In this example, a markdown template file is added to the repository at `.github/pull-request-template.md` with the following content.
+```
+This is a test pull request template
+Render template variables such as {{ .foo }} and {{ .bar }}.
+```
+
+The template is rendered using the [render-template](https://github.com/chuhlomin/render-template) action and the result is used to create the pull request.
+```yml
+      - name: Render template
+        id: template
+        uses: chuhlomin/render-template@v1.2
+        with:
+          template: .github/pull-request-template.md
+          vars: |
+            foo: this
+            bar: that
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          body: ${{ steps.template.outputs.result }}
 ```
 
 ### Debugging GitHub Actions
 
 #### Runner Diagnostic Logging
 
-[Runner diagnostic logging](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#enabling-runner-diagnostic-logging) provides additional log files that contain information about how a runner is executing an action.
+[Runner diagnostic logging](https://docs.github.com/en/actions/configuring-and-managing-workflows/managing-a-workflow-run#enabling-runner-diagnostic-logging) provides additional log files that contain information about how a runner is executing an action.
 To enable runner diagnostic logging, set the secret `ACTIONS_RUNNER_DEBUG` to `true` in the repository that contains the workflow.
 
 #### Step Debug Logging
 
-[Step debug logging](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#enabling-step-debug-logging) increases the verbosity of a job's logs during and after a job's execution.
+[Step debug logging](https://docs.github.com/en/actions/configuring-and-managing-workflows/managing-a-workflow-run#enabling-step-debug-logging) increases the verbosity of a job's logs during and after a job's execution.
 To enable step debug logging set the secret `ACTIONS_STEP_DEBUG` to `true` in the repository that contains the workflow.
 
 #### Output Various Contexts

docs/updating.md

@@ -1,25 +1,73 @@
-# Updating from `v1` to `v2`
+## Updating from `v2` to `v3`
 
-## Breaking changes
+### Breaking changes
+
+- The `author` input now defaults to the user who triggered the workflow run. This default is set via [action.yml](../action.yml) as `${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>`, where `github.actor` is the GitHub user account associated with the run. For example, `peter-evans <peter-evans@users.noreply.github.com>`.
+
+  To continue to use the `v2` default, set the `author` input as follows.
+  ```yaml
+      - uses: peter-evans/create-pull-request@v3
+        with:
+          author: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
+  ```
+
+- The `author` and `committer` inputs are no longer cross-used if only one is supplied. Additionally, when neither input is set, the `author` and `committer` are no longer determined from an existing identity set in git config. In both cases, the inputs will fall back to their default set in [action.yml](../action.yml).
+
+- Deprecated inputs `project` and `project-column` have been removed in favour of an additional action step. See [Create a project card](https://github.com/peter-evans/create-pull-request#create-a-project-card) for details.
+
+- Deprecated output `pr_number` has been removed in favour of `pull-request-number`.
+
+- Input `request-to-parent` has been removed in favour of `push-to-fork`. This greatly simplifies pushing the pull request branch to a fork of the parent repository. See [Push pull request branches to a fork](concepts-guidelines.md#push-pull-request-branches-to-a-fork) for details.
+
+  e.g.
+  ```yaml
+      - uses: actions/checkout@v2
+
+      # Make changes to pull request here
+
+      - uses: peter-evans/create-pull-request@v3
+        with:
+          token: ${{ secrets.MACHINE_USER_PAT }}
+          push-to-fork: machine-user/fork-of-repository
+  ```
+
+### New features
+
+- The action has been converted to Typescript giving it a significant performance improvement.
+
+- If you run this action in a container, or on [self-hosted runners](https://docs.github.com/en/actions/hosting-your-own-runners), `python` and `pip` are no longer required dependencies. See [Running in a container or on self-hosted runners](concepts-guidelines.md#running-in-a-container-or-on-self-hosted-runners) for details.
+
+- Inputs `labels`, `assignees`, `reviewers` and `team-reviewers` can now be newline separated, or comma separated.
+  e.g.
+  ```yml
+          labels: |
+            chore
+            dependencies
+            automated
+  ```
+
+## Updating from `v1` to `v2`
+
+### Breaking changes
 
 - `v2` now expects repositories to be checked out with `actions/checkout@v2`
 
   To use `actions/checkout@v1` the following step to checkout the branch is necessary.
-  ```
+  ```yml
       - uses: actions/checkout@v1
       - name: Checkout branch
         run: git checkout "${GITHUB_REF:11}"
   ```
 
-- The two branch naming strategies have been swapped. Fixed branch naming strategy is now the default. i.e. `branch-suffix: none` is now the default and should be removed from configuration if set.
+- The two branch naming strategies have been swapped. Fixed-branch naming strategy is now the default. i.e. `branch-suffix: none` is now the default and should be removed from configuration if set.
 
 - `author-name`, `author-email`, `committer-name`, `committer-email` have been removed in favour of `author` and `committer`.
   They can both be set in the format `Display Name <email@address.com>`
 
   If neither `author` or `committer` are set the action will default to making commits as the GitHub Actions bot user.
 
-## New features
+### New features
 
-- Unpushed commits made during the workflow before the action runs will now be considered as changes to be raised in the pull request. See [Controlling commits](https://github.com/peter-evans/create-pull-request#controlling-commits) for details.
+- Unpushed commits made during the workflow before the action runs will now be considered as changes to be raised in the pull request. See [Create your own commits](https://github.com/peter-evans/create-pull-request#create-your-own-commits) for details.
 - New commits made to the pull request base will now be taken into account when pull requests are updated.
 - If an updated pull request no longer differs from its base it will automatically be closed and the pull request branch deleted.

index.js

@@ -1,89 +0,0 @@
-const { inspect } = require("util");
-const isDocker = require("is-docker");
-const core = require("@actions/core");
-const exec = require("@actions/exec");
-const setupPython = require("./src/setup-python");
-
-async function run() {
-  try {
-    // Allows ncc to find assets to be included in the distribution
-    const src = __dirname + "/src";
-    core.debug(`src: ${src}`);
-
-    // Determine how to access python and pip
-    const { pip, python } = (function() {
-      if (isDocker()) {
-        core.info("Running inside a Docker container");
-        // Python 3 assumed to be installed and on the PATH
-        return {
-          pip: "pip3",
-          python: "python3"
-        };
-      } else {
-        // Setup Python from the tool cache
-        setupPython("3.x", "x64");
-        return {
-          pip: "pip",
-          python: "python"
-        };
-      }
-    })();
-
-    // Install requirements
-    await exec.exec(pip, [
-      "install",
-      "--requirement",
-      `${src}/requirements.txt`,
-      "--no-index",
-      `--find-links=${__dirname}/vendor`
-    ]);
-
-    // Fetch action inputs
-    const inputs = {
-      token: core.getInput("token"),
-      path: core.getInput("path"),
-      commitMessage: core.getInput("commit-message"),
-      committer: core.getInput("committer"),
-      author: core.getInput("author"),
-      title: core.getInput("title"),
-      body: core.getInput("body"),
-      labels: core.getInput("labels"),
-      assignees: core.getInput("assignees"),
-      reviewers: core.getInput("reviewers"),
-      teamReviewers: core.getInput("team-reviewers"),
-      milestone: core.getInput("milestone"),
-      project: core.getInput("project"),
-      projectColumn: core.getInput("project-column"),
-      branch: core.getInput("branch"),
-      base: core.getInput("base"),
-      branchSuffix: core.getInput("branch-suffix")
-    };
-    core.debug(`Inputs: ${inspect(inputs)}`);
-
-    // Set environment variables from inputs.
-    if (inputs.token) process.env.GITHUB_TOKEN = inputs.token;
-    if (inputs.path) process.env.CPR_PATH = inputs.path;
-    if (inputs.commitMessage) process.env.CPR_COMMIT_MESSAGE = inputs.commitMessage;
-    if (inputs.committer) process.env.CPR_COMMITTER = inputs.committer;
-    if (inputs.author) process.env.CPR_AUTHOR = inputs.author;
-    if (inputs.title) process.env.CPR_TITLE = inputs.title;
-    if (inputs.body) process.env.CPR_BODY = inputs.body;
-    if (inputs.labels) process.env.CPR_LABELS = inputs.labels;
-    if (inputs.assignees) process.env.CPR_ASSIGNEES = inputs.assignees;
-    if (inputs.reviewers) process.env.CPR_REVIEWERS = inputs.reviewers;
-    if (inputs.teamReviewers) process.env.CPR_TEAM_REVIEWERS = inputs.teamReviewers;
-    if (inputs.milestone) process.env.CPR_MILESTONE = inputs.milestone;
-    if (inputs.project) process.env.CPR_PROJECT_NAME = inputs.project;
-    if (inputs.projectColumn) process.env.CPR_PROJECT_COLUMN_NAME = inputs.projectColumn;
-    if (inputs.branch) process.env.CPR_BRANCH = inputs.branch;
-    if (inputs.base) process.env.CPR_BASE = inputs.base;
-    if (inputs.branchSuffix) process.env.CPR_BRANCH_SUFFIX = inputs.branchSuffix;
-
-    // Execute python script
-    await exec.exec(python, [`${src}/create_pull_request.py`]);
-  } catch (error) {
-    core.setFailed(error.message);
-  }
-}
-
-run();

jest.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  clearMocks: true,
+  moduleFileExtensions: ['js', 'ts'],
+  testEnvironment: 'node',
+  testMatch: ['**/*.test.ts'],
+  testRunner: 'jest-circus/runner',
+  transform: {
+    '^.+\\.ts$': 'ts-jest'
+  },
+  verbose: true
+}

package.json

@@ -1,19 +1,27 @@
 {
   "name": "create-pull-request",
-  "version": "2.0.0",
+  "version": "3.0.0",
+  "private": true,
   "description": "Creates a pull request for changes to your repository in the actions workspace",
-  "main": "index.js",
+  "main": "lib/main.js",
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "ncc build index.js -o dist",
-    "vendor-deps": "pip download -r src/requirements.txt --no-binary=:all: -d dist/vendor",
-    "package": "npm run build && npm run vendor-deps"
+    "build": "tsc && ncc build",
+    "format": "prettier --write '**/*.ts'",
+    "format-check": "prettier --check '**/*.ts'",
+    "lint": "eslint src/**/*.ts",
+    "test:unit": "jest unit",
+    "test:int": "__test__/integration-tests.sh",
+    "test": "npm run test:unit && npm run test:int"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peter-evans/create-pull-request.git"
   },
-  "keywords": [],
+  "keywords": [
+    "actions",
+    "pull",
+    "request"
+  ],
   "author": "Peter Evans",
   "license": "MIT",
   "bugs": {
@@ -21,12 +29,29 @@
   },
   "homepage": "https://github.com/peter-evans/create-pull-request",
   "dependencies": {
-    "@actions/core": "^1.1.1",
-    "@actions/exec": "^1.0.1",
-    "@actions/tool-cache": "^1.1.2",
-    "is-docker": "^2.0.0"
+    "@actions/core": "^1.6.0",
+    "@actions/exec": "^1.1.0",
+    "@octokit/core": "^3.5.1",
+    "@octokit/plugin-paginate-rest": "^2.17.0",
+    "@octokit/plugin-rest-endpoint-methods": "^5.13.0",
+    "https-proxy-agent": "^5.0.0",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@zeit/ncc": "0.21.1"
+    "@types/jest": "^27.0.3",
+    "@types/node": "^16.11.11",
+    "@typescript-eslint/parser": "^5.5.0",
+    "@vercel/ncc": "^0.32.0",
+    "eslint": "^8.3.0",
+    "eslint-import-resolver-typescript": "^2.5.0",
+    "eslint-plugin-github": "^4.3.5",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-jest": "^25.3.0",
+    "jest": "^27.4.3",
+    "jest-circus": "^27.4.2",
+    "js-yaml": "^4.1.0",
+    "prettier": "^2.5.0",
+    "ts-jest": "^27.0.7",
+    "typescript": "^4.5.2"
   }
 }

renovate.json

@@ -1,5 +0,0 @@
-{
-  "extends": [
-    "config:base"
-  ]
-}

src/common.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-import random
-import re
-import string
-
-
-def get_random_string(length=7, chars=string.ascii_lowercase + string.digits):
-    return "".join(random.choice(chars) for _ in range(length))
-
-
-def parse_github_repository(url):
-    # Parse the protocol and github repository from a URL
-    # e.g. HTTPS, peter-evans/create-pull-request
-    https_pattern = re.compile(r"^https://github.com/(.+/.+)$")
-    ssh_pattern = re.compile(r"^git@github.com:(.+/.+).git$")
-
-    match = https_pattern.match(url)
-    if match is not None:
-        return "HTTPS", match.group(1)
-
-    match = ssh_pattern.match(url)
-    if match is not None:
-        return "SSH", match.group(1)
-
-    raise ValueError(f"The format of '{url}' is not a valid GitHub repository URL")
-
-
-def parse_display_name_email(display_name_email):
-    # Parse the name and email address from a string in the following format
-    # Display Name <email@address.com>
-    pattern = re.compile(r"^([^<]+)\s*<([^>]+)>$")
-
-    # Check we have a match
-    match = pattern.match(display_name_email)
-    if match is None:
-        raise ValueError(
-            f"The format of '{display_name_email}' is not a valid email address with display name"
-        )
-
-    # Check that name and email are not just whitespace
-    name = match.group(1).strip()
-    email = match.group(2).strip()
-    if len(name) == 0 or len(email) == 0:
-        raise ValueError(
-            f"The format of '{display_name_email}' is not a valid email address with display name"
-        )
-
-    return name, email

src/create-or-update-branch.ts

@@ -0,0 +1,255 @@
+import * as core from '@actions/core'
+import {GitCommandManager} from './git-command-manager'
+import {v4 as uuidv4} from 'uuid'
+
+const CHERRYPICK_EMPTY =
+  'The previous cherry-pick is now empty, possibly due to conflict resolution.'
+
+export enum WorkingBaseType {
+  Branch = 'branch',
+  Commit = 'commit'
+}
+
+export async function getWorkingBaseAndType(
+  git: GitCommandManager
+): Promise<[string, WorkingBaseType]> {
+  const symbolicRefResult = await git.exec(
+    ['symbolic-ref', 'HEAD', '--short'],
+    true
+  )
+  if (symbolicRefResult.exitCode == 0) {
+    // A ref is checked out
+    return [symbolicRefResult.stdout.trim(), WorkingBaseType.Branch]
+  } else {
+    // A commit is checked out (detached HEAD)
+    const headSha = await git.revParse('HEAD')
+    return [headSha, WorkingBaseType.Commit]
+  }
+}
+
+export async function tryFetch(
+  git: GitCommandManager,
+  remote: string,
+  branch: string
+): Promise<boolean> {
+  try {
+    await git.fetch([`${branch}:refs/remotes/${remote}/${branch}`], remote)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// Return true if branch2 is ahead of branch1
+async function isAhead(
+  git: GitCommandManager,
+  branch1: string,
+  branch2: string
+): Promise<boolean> {
+  const result = await git.revList(
+    [`${branch1}...${branch2}`],
+    ['--right-only', '--count']
+  )
+  return Number(result) > 0
+}
+
+// Return true if branch2 is behind branch1
+async function isBehind(
+  git: GitCommandManager,
+  branch1: string,
+  branch2: string
+): Promise<boolean> {
+  const result = await git.revList(
+    [`${branch1}...${branch2}`],
+    ['--left-only', '--count']
+  )
+  return Number(result) > 0
+}
+
+// Return true if branch2 is even with branch1
+async function isEven(
+  git: GitCommandManager,
+  branch1: string,
+  branch2: string
+): Promise<boolean> {
+  return (
+    !(await isAhead(git, branch1, branch2)) &&
+    !(await isBehind(git, branch1, branch2))
+  )
+}
+
+function splitLines(multilineString: string): string[] {
+  return multilineString
+    .split('\n')
+    .map(s => s.trim())
+    .filter(x => x !== '')
+}
+
+export async function createOrUpdateBranch(
+  git: GitCommandManager,
+  commitMessage: string,
+  base: string,
+  branch: string,
+  branchRemoteName: string,
+  signoff: boolean,
+  addPaths: string[]
+): Promise<CreateOrUpdateBranchResult> {
+  // Get the working base.
+  // When a ref, it may or may not be the actual base.
+  // When a commit, we must rebase onto the actual base.
+  const [workingBase, workingBaseType] = await getWorkingBaseAndType(git)
+  core.info(`Working base is ${workingBaseType} '${workingBase}'`)
+  if (workingBaseType == WorkingBaseType.Commit && !base) {
+    throw new Error(`When in 'detached HEAD' state, 'base' must be supplied.`)
+  }
+
+  // If the base is not specified it is assumed to be the working base.
+  base = base ? base : workingBase
+  const baseRemote = 'origin'
+
+  // Set the default return values
+  const result: CreateOrUpdateBranchResult = {
+    action: 'none',
+    base: base,
+    hasDiffWithBase: false,
+    headSha: ''
+  }
+
+  // Save the working base changes to a temporary branch
+  const tempBranch = uuidv4()
+  await git.checkout(tempBranch, 'HEAD')
+  // Commit any uncommitted changes
+  if (await git.isDirty(true)) {
+    core.info('Uncommitted changes found. Adding a commit.')
+    for (const path of addPaths) {
+      await git.exec(['add', path], true)
+    }
+    const params = ['-m', commitMessage]
+    if (signoff) {
+      params.push('--signoff')
+    }
+    await git.commit(params)
+    // Remove uncommitted tracked and untracked changes
+    await git.exec(['reset', '--hard'])
+    await git.exec(['clean', '-f'])
+  }
+
+  // Perform fetch and reset the working base
+  // Commits made during the workflow will be removed
+  if (workingBaseType == WorkingBaseType.Branch) {
+    core.info(`Resetting working base branch '${workingBase}'`)
+    if (branchRemoteName == 'fork') {
+      // If pushing to a fork we must fetch with 'unshallow' to avoid the following error on git push
+      // ! [remote rejected] HEAD -> tests/push-branch-to-fork (shallow update not allowed)
+      await git.fetch([`${workingBase}:${workingBase}`], baseRemote, [
+        '--force'
+      ])
+    } else {
+      // If the remote is 'origin' we can git reset
+      await git.checkout(workingBase)
+      await git.exec(['reset', '--hard', `${baseRemote}/${workingBase}`])
+    }
+  }
+
+  // If the working base is not the base, rebase the temp branch commits
+  // This will also be true if the working base type is a commit
+  if (workingBase != base) {
+    core.info(
+      `Rebasing commits made to ${workingBaseType} '${workingBase}' on to base branch '${base}'`
+    )
+    // Checkout the actual base
+    await git.fetch([`${base}:${base}`], baseRemote, ['--force'])
+    await git.checkout(base)
+    // Cherrypick commits from the temporary branch starting from the working base
+    const commits = await git.revList(
+      [`${workingBase}..${tempBranch}`, '.'],
+      ['--reverse']
+    )
+    for (const commit of splitLines(commits)) {
+      const result = await git.cherryPick(
+        ['--strategy=recursive', '--strategy-option=theirs', commit],
+        true
+      )
+      if (result.exitCode != 0 && !result.stderr.includes(CHERRYPICK_EMPTY)) {
+        throw new Error(`Unexpected error: ${result.stderr}`)
+      }
+    }
+    // Reset the temp branch to the working index
+    await git.checkout(tempBranch, 'HEAD')
+    // Reset the base
+    await git.fetch([`${base}:${base}`], baseRemote, ['--force'])
+  }
+
+  // Try to fetch the pull request branch
+  if (!(await tryFetch(git, branchRemoteName, branch))) {
+    // The pull request branch does not exist
+    core.info(`Pull request branch '${branch}' does not exist yet.`)
+    // Create the pull request branch
+    await git.checkout(branch, tempBranch)
+    // Check if the pull request branch is ahead of the base
+    result.hasDiffWithBase = await isAhead(git, base, branch)
+    if (result.hasDiffWithBase) {
+      result.action = 'created'
+      core.info(`Created branch '${branch}'`)
+    } else {
+      core.info(
+        `Branch '${branch}' is not ahead of base '${base}' and will not be created`
+      )
+    }
+  } else {
+    // The pull request branch exists
+    core.info(
+      `Pull request branch '${branch}' already exists as remote branch '${branchRemoteName}/${branch}'`
+    )
+    // Checkout the pull request branch
+    await git.checkout(branch)
+
+    // Reset the branch if one of the following conditions is true.
+    // - If the branch differs from the recreated temp branch.
+    // - If the recreated temp branch is not ahead of the base. This means there will be
+    //   no pull request diff after the branch is reset. This will reset any undeleted
+    //   branches after merging. In particular, it catches a case where the branch was
+    //   squash merged but not deleted. We need to reset to make sure it doesn't appear
+    //   to have a diff with the base due to different commits for the same changes.
+    // For changes on base this reset is equivalent to a rebase of the pull request branch.
+    if (
+      (await git.hasDiff([`${branch}..${tempBranch}`])) ||
+      !(await isAhead(git, base, tempBranch))
+    ) {
+      core.info(`Resetting '${branch}'`)
+      // Alternatively, git switch -C branch tempBranch
+      await git.checkout(branch, tempBranch)
+    }
+
+    // Check if the pull request branch has been updated
+    // If the branch was reset or updated it will be ahead
+    // It may be behind if a reset now results in no diff with the base
+    if (!(await isEven(git, `${branchRemoteName}/${branch}`, branch))) {
+      result.action = 'updated'
+      core.info(`Updated branch '${branch}'`)
+    } else {
+      result.action = 'not-updated'
+      core.info(
+        `Branch '${branch}' is even with its remote and will not be updated`
+      )
+    }
+
+    // Check if the pull request branch is ahead of the base
+    result.hasDiffWithBase = await isAhead(git, base, branch)
+  }
+
+  // Get the pull request branch SHA
+  result.headSha = await git.revParse('HEAD')
+
+  // Delete the temporary branch
+  await git.exec(['branch', '--delete', '--force', tempBranch])
+
+  return result
+}
+
+interface CreateOrUpdateBranchResult {
+  action: string
+  base: string
+  hasDiffWithBase: boolean
+  headSha: string
+}

src/create-pull-request.ts

@@ -0,0 +1,252 @@
+import * as core from '@actions/core'
+import {
+  createOrUpdateBranch,
+  getWorkingBaseAndType,
+  WorkingBaseType
+} from './create-or-update-branch'
+import {GitHubHelper} from './github-helper'
+import {GitCommandManager} from './git-command-manager'
+import {GitAuthHelper} from './git-auth-helper'
+import * as utils from './utils'
+
+export interface Inputs {
+  token: string
+  path: string
+  addPaths: string[]
+  commitMessage: string
+  committer: string
+  author: string
+  signoff: boolean
+  branch: string
+  deleteBranch: boolean
+  branchSuffix: string
+  base: string
+  pushToFork: string
+  title: string
+  body: string
+  labels: string[]
+  assignees: string[]
+  reviewers: string[]
+  teamReviewers: string[]
+  milestone: number
+  draft: boolean
+}
+
+export async function createPullRequest(inputs: Inputs): Promise<void> {
+  let gitAuthHelper
+  try {
+    // Get the repository path
+    const repoPath = utils.getRepoPath(inputs.path)
+    // Create a git command manager
+    const git = await GitCommandManager.create(repoPath)
+
+    // Save and unset the extraheader auth config if it exists
+    core.startGroup('Save persisted git credentials')
+    gitAuthHelper = new GitAuthHelper(git)
+    await gitAuthHelper.savePersistedAuth()
+    core.endGroup()
+
+    // Init the GitHub client
+    const githubHelper = new GitHubHelper(inputs.token)
+
+    core.startGroup('Determining the base and head repositories')
+    // Determine the base repository from git config
+    const remoteUrl = await git.tryGetRemoteUrl()
+    const baseRemote = utils.getRemoteDetail(remoteUrl)
+    // Determine the head repository; the target for the pull request branch
+    const branchRemoteName = inputs.pushToFork ? 'fork' : 'origin'
+    const branchRepository = inputs.pushToFork
+      ? inputs.pushToFork
+      : baseRemote.repository
+    if (inputs.pushToFork) {
+      // Check if the supplied fork is really a fork of the base
+      const parentRepository = await githubHelper.getRepositoryParent(
+        branchRepository
+      )
+      if (parentRepository != baseRemote.repository) {
+        throw new Error(
+          `Repository '${branchRepository}' is not a fork of '${baseRemote.repository}'. Unable to continue.`
+        )
+      }
+      // Add a remote for the fork
+      const remoteUrl = utils.getRemoteUrl(
+        baseRemote.protocol,
+        branchRepository
+      )
+      await git.exec(['remote', 'add', 'fork', remoteUrl])
+    }
+    core.endGroup()
+    core.info(
+      `Pull request branch target repository set to ${branchRepository}`
+    )
+
+    // Configure auth
+    if (baseRemote.protocol == 'HTTPS') {
+      core.startGroup('Configuring credential for HTTPS authentication')
+      await gitAuthHelper.configureToken(inputs.token)
+      core.endGroup()
+    }
+
+    core.startGroup('Checking the base repository state')
+    const [workingBase, workingBaseType] = await getWorkingBaseAndType(git)
+    core.info(`Working base is ${workingBaseType} '${workingBase}'`)
+    // When in detached HEAD state (checked out on a commit), we need to
+    // know the 'base' branch in order to rebase changes.
+    if (workingBaseType == WorkingBaseType.Commit && !inputs.base) {
+      throw new Error(
+        `When the repository is checked out on a commit instead of a branch, the 'base' input must be supplied.`
+      )
+    }
+    // If the base is not specified it is assumed to be the working base.
+    const base = inputs.base ? inputs.base : workingBase
+    // Throw an error if the base and branch are not different branches
+    // of the 'origin' remote. An identically named branch in the `fork`
+    // remote is perfectly fine.
+    if (branchRemoteName == 'origin' && base == inputs.branch) {
+      throw new Error(
+        `The 'base' and 'branch' for a pull request must be different branches. Unable to continue.`
+      )
+    }
+    // For self-hosted runners the repository state persists between runs.
+    // This command prunes the stale remote ref when the pull request branch was
+    // deleted after being merged or closed. Without this the push using
+    // '--force-with-lease' fails due to "stale info."
+    // https://github.com/peter-evans/create-pull-request/issues/633
+    await git.exec(['remote', 'prune', branchRemoteName])
+    core.endGroup()
+
+    // Apply the branch suffix if set
+    if (inputs.branchSuffix) {
+      switch (inputs.branchSuffix) {
+        case 'short-commit-hash':
+          // Suffix with the short SHA1 hash
+          inputs.branch = `${inputs.branch}-${await git.revParse('HEAD', [
+            '--short'
+          ])}`
+          break
+        case 'timestamp':
+          // Suffix with the current timestamp
+          inputs.branch = `${inputs.branch}-${utils.secondsSinceEpoch()}`
+          break
+        case 'random':
+          // Suffix with a 7 character random string
+          inputs.branch = `${inputs.branch}-${utils.randomString()}`
+          break
+        default:
+          throw new Error(
+            `Branch suffix '${inputs.branchSuffix}' is not a valid value. Unable to continue.`
+          )
+      }
+    }
+
+    // Output head branch
+    core.info(
+      `Pull request branch to create or update set to '${inputs.branch}'`
+    )
+
+    // Configure the committer and author
+    core.startGroup('Configuring the committer and author')
+    const parsedAuthor = utils.parseDisplayNameEmail(inputs.author)
+    const parsedCommitter = utils.parseDisplayNameEmail(inputs.committer)
+    git.setIdentityGitOptions([
+      '-c',
+      `author.name=${parsedAuthor.name}`,
+      '-c',
+      `author.email=${parsedAuthor.email}`,
+      '-c',
+      `committer.name=${parsedCommitter.name}`,
+      '-c',
+      `committer.email=${parsedCommitter.email}`
+    ])
+    core.info(
+      `Configured git committer as '${parsedCommitter.name} <${parsedCommitter.email}>'`
+    )
+    core.info(
+      `Configured git author as '${parsedAuthor.name} <${parsedAuthor.email}>'`
+    )
+    core.endGroup()
+
+    // Create or update the pull request branch
+    core.startGroup('Create or update the pull request branch')
+    const result = await createOrUpdateBranch(
+      git,
+      inputs.commitMessage,
+      inputs.base,
+      inputs.branch,
+      branchRemoteName,
+      inputs.signoff,
+      inputs.addPaths
+    )
+    core.endGroup()
+
+    if (['created', 'updated'].includes(result.action)) {
+      // The branch was created or updated
+      core.startGroup(
+        `Pushing pull request branch to '${branchRemoteName}/${inputs.branch}'`
+      )
+      await git.push([
+        '--force-with-lease',
+        branchRemoteName,
+        `HEAD:refs/heads/${inputs.branch}`
+      ])
+      core.endGroup()
+    }
+
+    // Set the base. It would have been '' if not specified as an input
+    inputs.base = result.base
+
+    if (result.hasDiffWithBase) {
+      // Create or update the pull request
+      core.startGroup('Create or update the pull request')
+      const pull = await githubHelper.createOrUpdatePullRequest(
+        inputs,
+        baseRemote.repository,
+        branchRepository
+      )
+      core.endGroup()
+
+      // Set outputs
+      core.startGroup('Setting outputs')
+      core.setOutput('pull-request-number', pull.number)
+      core.setOutput('pull-request-url', pull.html_url)
+      if (pull.created) {
+        core.setOutput('pull-request-operation', 'created')
+      } else if (result.action == 'updated') {
+        core.setOutput('pull-request-operation', 'updated')
+      }
+      core.setOutput('pull-request-head-sha', result.headSha)
+      // Deprecated
+      core.exportVariable('PULL_REQUEST_NUMBER', pull.number)
+      core.endGroup()
+    } else {
+      // There is no longer a diff with the base
+      // Check we are in a state where a branch exists
+      if (['updated', 'not-updated'].includes(result.action)) {
+        core.info(
+          `Branch '${inputs.branch}' no longer differs from base branch '${inputs.base}'`
+        )
+        if (inputs.deleteBranch) {
+          core.info(`Deleting branch '${inputs.branch}'`)
+          await git.push([
+            '--delete',
+            '--force',
+            branchRemoteName,
+            `refs/heads/${inputs.branch}`
+          ])
+          // Set outputs
+          core.startGroup('Setting outputs')
+          core.setOutput('pull-request-operation', 'closed')
+          core.endGroup()
+        }
+      }
+    }
+  } catch (error: any) {
+    core.setFailed(error.message)
+  } finally {
+    // Remove auth and restore persisted auth config if it existed
+    core.startGroup('Restore persisted git credentials')
+    await gitAuthHelper.removeAuth()
+    await gitAuthHelper.restorePersistedAuth()
+    core.endGroup()
+  }
+}

src/create_or_update_branch.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-""" Create or Update Branch """
-import common as cmn
-from git import Repo, GitCommandError
-import os
-
-
-CHERRYPICK_EMPTY = (
-    "The previous cherry-pick is now empty, possibly due to conflict resolution."
-)
-
-
-def fetch_successful(repo, repo_url, branch):
-    try:
-        repo.git.fetch(repo_url, f"{branch}:refs/remotes/origin/{branch}")
-    except GitCommandError:
-        return False
-    return True
-
-
-def is_ahead(repo, branch_1, branch_2):
-    # Return true if branch_2 is ahead of branch_1
-    return (
-        int(repo.git.rev_list("--right-only", "--count", f"{branch_1}...{branch_2}"))
-        > 0
-    )
-
-
-def is_behind(repo, branch_1, branch_2):
-    # Return true if branch_2 is behind branch_1
-    return (
-        int(repo.git.rev_list("--left-only", "--count", f"{branch_1}...{branch_2}")) > 0
-    )
-
-
-def is_even(repo, branch_1, branch_2):
-    # Return true if branch_2 is even with branch_1
-    return not is_ahead(repo, branch_1, branch_2) and not is_behind(
-        repo, branch_1, branch_2
-    )
-
-
-def has_diff(repo, branch_1, branch_2):
-    diff = repo.git.diff(f"{branch_1}..{branch_2}")
-    return len(diff) > 0
-
-
-def create_or_update_branch(repo, repo_url, commit_message, base, branch):
-    # Set the default return values
-    action = "none"
-    diff = False
-
-    # Get the working base. This may or may not be the actual base.
-    working_base = repo.git.symbolic_ref("HEAD", "--short")
-    # If the base is not specified it is assumed to be the working base
-    if base is None:
-        base = working_base
-
-    # Save the working base changes to a temporary branch
-    temp_branch = cmn.get_random_string(length=20)
-    repo.git.checkout("HEAD", b=temp_branch)
-    # Commit any uncomitted changes
-    if repo.is_dirty(untracked_files=True):
-        print(f"Uncommitted changes found. Adding a commit.")
-        repo.git.add("-A")
-        repo.git.commit(m=commit_message)
-
-    # Perform fetch and reset the working base
-    # Commits made during the workflow will be removed
-    repo.git.fetch("--force", repo_url, f"{working_base}:{working_base}")
-
-    # If the working base is not the base, rebase the temp branch commits
-    if working_base != base:
-        print(
-            f"Rebasing commits made to branch '{working_base}' on to base branch '{base}'"
-        )
-        # Checkout the actual base
-        repo.git.fetch("--force", repo_url, f"{base}:{base}")
-        repo.git.checkout(base)
-        # Cherrypick commits from the temporary branch starting from the working base
-        commits = repo.git.rev_list("--reverse", f"{working_base}..{temp_branch}", ".")
-        for commit in commits.splitlines():
-            try:
-                repo.git.cherry_pick(
-                    "--strategy",
-                    "recursive",
-                    "--strategy-option",
-                    "theirs",
-                    f"{commit}",
-                )
-            except GitCommandError as e:
-                if CHERRYPICK_EMPTY not in e.stderr:
-                    print("Unexpected error: ", e)
-                    raise
-        # Reset the temp branch to the working index
-        repo.git.checkout("-B", temp_branch, "HEAD")
-        # Reset the base
-        repo.git.fetch("--force", repo_url, f"{base}:{base}")
-
-    # Try to fetch the pull request branch
-    if not fetch_successful(repo, repo_url, branch):
-        # The pull request branch does not exist
-        print(f"Pull request branch '{branch}' does not exist yet")
-        # Create the pull request branch
-        repo.git.checkout("HEAD", b=branch)
-        # Check if the pull request branch is ahead of the base
-        diff = is_ahead(repo, base, branch)
-        if diff:
-            action = "created"
-            print(f"Created branch '{branch}'")
-        else:
-            print(
-                f"Branch '{branch}' is not ahead of base '{base}' and will not be created"
-            )
-    else:
-        # The pull request branch exists
-        print(
-            f"Pull request branch '{branch}' already exists as remote branch 'origin/{branch}'"
-        )
-        # Checkout the pull request branch
-        repo.git.checkout(branch)
-
-        if has_diff(repo, branch, temp_branch):
-            # If the branch differs from the recreated temp version then the branch is reset
-            # For changes on base this action is similar to a rebase of the pull request branch
-            print(f"Resetting '{branch}'")
-            repo.git.checkout("-B", branch, temp_branch)
-            # repo.git.switch("-C", branch, temp_branch)
-
-        # Check if the pull request branch has been updated
-        # If the branch was reset or updated it will be ahead
-        # It may be behind if a reset now results in no diff with the base
-        if not is_even(repo, f"origin/{branch}", branch):
-            action = "updated"
-            print(f"Updated branch '{branch}'")
-        else:
-            print(f"Branch '{branch}' is even with its remote and will not be updated")
-
-        # Check if the pull request branch is ahead of the base
-        diff = is_ahead(repo, base, branch)
-
-    # Delete the temporary branch
-    repo.git.branch("--delete", "--force", temp_branch)
-
-    return {"action": action, "diff": diff, "base": base}

src/create_or_update_pull_request.py

@@ -1,128 +0,0 @@
-#!/usr/bin/env python3
-""" Create or Update Pull Request """
-from github import Github, GithubException
-import os
-
-
-def cs_string_to_list(str):
-    # Split the comma separated string into a list
-    l = [i.strip() for i in str.split(",")]
-    # Remove empty strings
-    return list(filter(None, l))
-
-
-def create_project_card(github_repo, project_name, project_column_name, pull_request):
-    # Locate the project by name
-    project = None
-    for project_item in github_repo.get_projects("all"):
-        if project_item.name == project_name:
-            project = project_item
-            break
-
-    if not project:
-        print("::error::Project not found. Unable to create project card.")
-        return
-
-    # Locate the column by name
-    column = None
-    for column_item in project.get_columns():
-        if column_item.name == project_column_name:
-            column = column_item
-            break
-
-    if not column:
-        print("::error::Project column not found. Unable to create project card.")
-        return
-
-    # Create a project card for the pull request
-    column.create_card(content_id=pull_request.id, content_type="PullRequest")
-    print(
-        "Added pull request #%d to project '%s' under column '%s'"
-        % (pull_request.number, project.name, column.name)
-    )
-
-
-def create_or_update_pull_request(
-    github_token,
-    github_repository,
-    branch,
-    base,
-    title,
-    body,
-    labels,
-    assignees,
-    milestone,
-    reviewers,
-    team_reviewers,
-    project_name,
-    project_column_name,
-):
-    # Create the pull request
-    github_repo = Github(github_token).get_repo(github_repository)
-    try:
-        pull_request = github_repo.create_pull(
-            title=title, body=body, base=base, head=branch
-        )
-        print(f"Created pull request #{pull_request.number} ({branch} => {base})")
-    except GithubException as e:
-        if e.status == 422:
-            # A pull request exists for this branch and base
-            head_branch = "{}:{}".format(github_repository.split("/")[0], branch)
-            # Get the pull request
-            pull_request = github_repo.get_pulls(
-                state="open", base=base, head=head_branch
-            )[0]
-            # Update title and body
-            pull_request.as_issue().edit(title=title, body=body)
-            print(f"Updated pull request #{pull_request.number} ({branch} => {base})")
-        else:
-            print(str(e))
-            raise
-
-    # Set the output variables
-    os.system(f"echo ::set-env name=PULL_REQUEST_NUMBER::{pull_request.number}")
-    os.system(f"echo ::set-output name=pr_number::{pull_request.number}")
-
-    # Set labels, assignees and milestone
-    if labels is not None:
-        print(f"Applying labels '{labels}'")
-        pull_request.as_issue().edit(labels=cs_string_to_list(labels))
-    if assignees is not None:
-        print(f"Applying assignees '{assignees}'")
-        pull_request.as_issue().edit(assignees=cs_string_to_list(assignees))
-    if milestone is not None:
-        print(f"Applying milestone '{milestone}'")
-        milestone = github_repo.get_milestone(int(milestone))
-        pull_request.as_issue().edit(milestone=milestone)
-
-    # Set pull request reviewers
-    if reviewers is not None:
-        print(f"Requesting reviewers '{reviewers}'")
-        try:
-            pull_request.create_review_request(reviewers=cs_string_to_list(reviewers))
-        except GithubException as e:
-            # Likely caused by "Review cannot be requested from pull request author."
-            if e.status == 422:
-                print("Request reviewers failed - {}".format(e.data["message"]))
-
-    # Set pull request team reviewers
-    if team_reviewers is not None:
-        print(f"Requesting team reviewers '{team_reviewers}'")
-        pull_request.create_review_request(
-            team_reviewers=cs_string_to_list(team_reviewers)
-        )
-
-    # Create a project card for the pull request
-    if project_name is not None and project_column_name is not None:
-        try:
-            create_project_card(
-                github_repo, project_name, project_column_name, pull_request
-            )
-        except GithubException as e:
-            # Likely caused by "Project already has the associated issue."
-            if e.status == 422:
-                print(
-                    "Create project card failed - {}".format(
-                        e.data["errors"][0]["message"]
-                    )
-                )

src/create_pull_request.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-""" Create Pull Request """
-import common as cmn
-import create_or_update_branch as coub
-import create_or_update_pull_request as coupr
-from git import Repo, GitCommandError
-import json
-import os
-import sys
-import time
-
-
-# Default the committer and author to the GitHub Actions bot
-DEFAULT_COMMITTER = "GitHub <noreply@github.com>"
-DEFAULT_AUTHOR = (
-    "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"
-)
-DEFAULT_COMMIT_MESSAGE = "[create-pull-request] automated change"
-DEFAULT_TITLE = "Changes by create-pull-request action"
-DEFAULT_BODY = (
-    "Automated changes by "
-    + "[create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action"
-)
-DEFAULT_BRANCH = "create-pull-request/patch"
-
-
-def get_git_config_value(repo, name):
-    try:
-        return repo.git.config("--get", name)
-    except GitCommandError:
-        return None
-
-
-def get_repository_detail():
-    remote_origin_url = get_git_config_value(repo, "remote.origin.url")
-    if remote_origin_url is None:
-        raise ValueError("Failed to fetch 'remote.origin.url' from git config")
-    protocol, github_repository = cmn.parse_github_repository(remote_origin_url)
-    return remote_origin_url, protocol, github_repository
-
-
-def git_user_config_is_set(repo):
-    name = get_git_config_value(repo, "user.name")
-    email = get_git_config_value(repo, "user.email")
-
-    if name is not None and email is not None:
-        print(f"Git user already configured as '{name} <{email}>'")
-        return True
-
-    committer_name = get_git_config_value(repo, "committer.name")
-    committer_email = get_git_config_value(repo, "committer.email")
-    author_name = get_git_config_value(repo, "author.name")
-    author_email = get_git_config_value(repo, "author.email")
-
-    if (
-        committer_name is not None
-        and committer_email is not None
-        and author_name is not None
-        and author_email is not None
-    ):
-        print(
-            f"Git committer already configured as '{committer_name} <{committer_email}>'"
-        )
-        print(f"Git author already configured as '{author_name} <{author_email}>'")
-        return True
-
-    return False
-
-
-def set_committer_author(repo, committer, author):
-    # If either committer or author is supplied they will be cross used
-    if committer is None and author is not None:
-        print("Supplied author will also be used as the committer.")
-        committer = author
-    if author is None and committer is not None:
-        print("Supplied committer will also be used as the author.")
-        author = committer
-
-    # If no committer/author has been supplied but user configuration already
-    # exists in git config we can exit and use the existing config as-is.
-    if committer is None and author is None:
-        if git_user_config_is_set(repo):
-            return
-
-    # Set defaults if no committer/author has been supplied
-    if committer is None and author is None:
-        committer = DEFAULT_COMMITTER
-        author = DEFAULT_AUTHOR
-
-    # Set git environment. This will not persist after the action completes.
-    committer_name, committer_email = cmn.parse_display_name_email(committer)
-    author_name, author_email = cmn.parse_display_name_email(author)
-    repo.git.update_environment(
-        GIT_COMMITTER_NAME=committer_name,
-        GIT_COMMITTER_EMAIL=committer_email,
-        GIT_AUTHOR_NAME=author_name,
-        GIT_AUTHOR_EMAIL=author_email,
-    )
-    print(f"Configured git committer as '{committer_name} <{committer_email}>'")
-    print(f"Configured git author as '{author_name} <{author_email}>'")
-
-
-# Get required environment variables
-github_token = os.environ["GITHUB_TOKEN"]
-# Get environment variables with defaults
-path = os.getenv("CPR_PATH", os.getcwd())
-branch = os.getenv("CPR_BRANCH", DEFAULT_BRANCH)
-commit_message = os.getenv("CPR_COMMIT_MESSAGE", DEFAULT_COMMIT_MESSAGE)
-# Get environment variables with a default of 'None'
-committer = os.environ.get("CPR_COMMITTER")
-author = os.environ.get("CPR_AUTHOR")
-base = os.environ.get("CPR_BASE")
-
-# Set the repo path
-repo = Repo(path)
-
-# Determine the GitHub repository from git config
-# This will be the target repository for the pull request
-repo_url, protocol, github_repository = get_repository_detail()
-print(f"Target repository set to {github_repository}")
-
-# Determine if the checked out ref is a valid base for a pull request
-# The action needs the checked out HEAD ref to be a branch
-# This check will fail in the following cases:
-# - HEAD is detached
-# - HEAD is a merge commit (pull_request events)
-# - HEAD is a tag
-try:
-    working_base = repo.git.symbolic_ref("HEAD", "--short")
-except GitCommandError as e:
-    print(f"::debug::{e.stderr}")
-    print(
-        f"::error::The checked out ref is not a valid base for a pull request. "
-        + "Unable to continue. Exiting."
-    )
-    sys.exit(1)
-
-# Exit if the working base is a PR branch created by this action.
-# This may occur when using a PAT instead of GITHUB_TOKEN because
-# a PAT allows workflow actions to trigger further events.
-if working_base.startswith(branch):
-    print(
-        f"::error::Working base branch '{working_base}' was created by this action. "
-        + "Unable to continue. Exiting."
-    )
-    sys.exit(1)
-
-# Fetch an optional environment variable to determine the branch suffix
-branch_suffix = os.environ.get("CPR_BRANCH_SUFFIX")
-if branch_suffix is not None:
-    if branch_suffix == "short-commit-hash":
-        # Suffix with the short SHA1 hash
-        branch = "{}-{}".format(branch, repo.git.rev_parse("--short", "HEAD"))
-    elif branch_suffix == "timestamp":
-        # Suffix with the current timestamp
-        branch = "{}-{}".format(branch, int(time.time()))
-    elif branch_suffix == "random":
-        # Suffix with a 7 character random string
-        branch = "{}-{}".format(branch, cmn.get_random_string())
-    else:
-        print(
-            f"::error::Branch suffix '{branch_suffix}' is not a valid value. "
-            + "Unable to continue. Exiting."
-        )
-        sys.exit(1)
-
-# Output head branch
-print(f"Pull request branch to create or update set to '{branch}'")
-
-# Set the committer and author
-try:
-    set_committer_author(repo, committer, author)
-except ValueError as e:
-    print(f"::error::{e} " + "Unable to continue. Exiting.")
-    sys.exit(1)
-
-# Set the auth token in the repo URL
-# This supports checkout@v1. From v2 the auth token is saved for further use.
-if protocol == "HTTPS":
-    repo_url = f"https://x-access-token:{github_token}@github.com/{github_repository}"
-
-# Create or update the pull request branch
-result = coub.create_or_update_branch(repo, repo_url, commit_message, base, branch)
-
-if result["action"] in ["created", "updated"]:
-    # The branch was created or updated
-    print(f"Pushing pull request branch to 'origin/{branch}'")
-    repo.git.push("--force", repo_url, f"HEAD:refs/heads/{branch}")
-
-    # Set the base. It would have been 'None' if not specified as an input
-    base = result["base"]
-
-    # If there is no longer a diff with the base delete the branch and exit
-    if not result["diff"]:
-        print(f"Branch '{branch}' no longer differs from base branch '{base}'")
-        print(f"Closing pull request and deleting branch '{branch}'")
-        repo.git.push("--delete", "--force", repo_url, f"refs/heads/{branch}")
-        sys.exit()
-
-    # Fetch optional environment variables with default values
-    title = os.getenv("CPR_TITLE", DEFAULT_TITLE)
-    body = os.getenv("CPR_BODY", DEFAULT_BODY)
-
-    # Create or update the pull request
-    coupr.create_or_update_pull_request(
-        github_token,
-        github_repository,
-        branch,
-        base,
-        title,
-        body,
-        os.environ.get("CPR_LABELS"),
-        os.environ.get("CPR_ASSIGNEES"),
-        os.environ.get("CPR_MILESTONE"),
-        os.environ.get("CPR_REVIEWERS"),
-        os.environ.get("CPR_TEAM_REVIEWERS"),
-        os.environ.get("CPR_PROJECT_NAME"),
-        os.environ.get("CPR_PROJECT_COLUMN_NAME"),
-    )

src/git-auth-helper.ts

@@ -0,0 +1,126 @@
+import * as core from '@actions/core'
+import * as fs from 'fs'
+import {GitCommandManager} from './git-command-manager'
+import * as path from 'path'
+import {URL} from 'url'
+
+export class GitAuthHelper {
+  private git: GitCommandManager
+  private gitConfigPath: string
+  private extraheaderConfigKey: string
+  private extraheaderConfigPlaceholderValue = 'AUTHORIZATION: basic ***'
+  private extraheaderConfigValueRegex = '^AUTHORIZATION:'
+  private persistedExtraheaderConfigValue = ''
+
+  constructor(git: GitCommandManager) {
+    this.git = git
+    this.gitConfigPath = path.join(
+      this.git.getWorkingDirectory(),
+      '.git',
+      'config'
+    )
+    const serverUrl = this.getServerUrl()
+    this.extraheaderConfigKey = `http.${serverUrl.origin}/.extraheader`
+  }
+
+  async savePersistedAuth(): Promise<void> {
+    // Save and unset persisted extraheader credential in git config if it exists
+    this.persistedExtraheaderConfigValue = await this.getAndUnset()
+  }
+
+  async restorePersistedAuth(): Promise<void> {
+    if (this.persistedExtraheaderConfigValue) {
+      try {
+        await this.setExtraheaderConfig(this.persistedExtraheaderConfigValue)
+        core.info('Persisted git credentials restored')
+      } catch (e: any) {
+        core.warning(e)
+      }
+    }
+  }
+
+  async configureToken(token: string): Promise<void> {
+    // Encode and configure the basic credential for HTTPS access
+    const basicCredential = Buffer.from(
+      `x-access-token:${token}`,
+      'utf8'
+    ).toString('base64')
+    core.setSecret(basicCredential)
+    const extraheaderConfigValue = `AUTHORIZATION: basic ${basicCredential}`
+    await this.setExtraheaderConfig(extraheaderConfigValue)
+  }
+
+  async removeAuth(): Promise<void> {
+    await this.getAndUnset()
+  }
+
+  private async setExtraheaderConfig(
+    extraheaderConfigValue: string
+  ): Promise<void> {
+    // Configure a placeholder value. This approach avoids the credential being captured
+    // by process creation audit events, which are commonly logged. For more information,
+    // refer to https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/manage/component-updates/command-line-process-auditing
+    // See https://github.com/actions/checkout/blob/main/src/git-auth-helper.ts#L267-L274
+    await this.git.config(
+      this.extraheaderConfigKey,
+      this.extraheaderConfigPlaceholderValue
+    )
+    // Replace the placeholder
+    await this.gitConfigStringReplace(
+      this.extraheaderConfigPlaceholderValue,
+      extraheaderConfigValue
+    )
+  }
+
+  private async getAndUnset(): Promise<string> {
+    let configValue = ''
+    // Save and unset persisted extraheader credential in git config if it exists
+    if (
+      await this.git.configExists(
+        this.extraheaderConfigKey,
+        this.extraheaderConfigValueRegex
+      )
+    ) {
+      configValue = await this.git.getConfigValue(
+        this.extraheaderConfigKey,
+        this.extraheaderConfigValueRegex
+      )
+      if (
+        await this.git.tryConfigUnset(
+          this.extraheaderConfigKey,
+          this.extraheaderConfigValueRegex
+        )
+      ) {
+        core.info(`Unset config key '${this.extraheaderConfigKey}'`)
+      } else {
+        core.warning(
+          `Failed to unset config key '${this.extraheaderConfigKey}'`
+        )
+      }
+    }
+    return configValue
+  }
+
+  private async gitConfigStringReplace(
+    find: string,
+    replace: string
+  ): Promise<void> {
+    let content = (await fs.promises.readFile(this.gitConfigPath)).toString()
+    const index = content.indexOf(find)
+    if (index < 0 || index != content.lastIndexOf(find)) {
+      throw new Error(`Unable to replace '${find}' in ${this.gitConfigPath}`)
+    }
+    content = content.replace(find, replace)
+    await fs.promises.writeFile(this.gitConfigPath, content)
+  }
+
+  private getServerUrl(): URL {
+    // todo: remove GITHUB_URL after support for GHES Alpha is no longer needed
+    // See https://github.com/actions/checkout/blob/main/src/url-helper.ts#L22-L29
+    return new URL(
+      process.env['GITHUB_SERVER_URL'] ||
+        process.env['GITHUB_URL'] ||
+        'https://github.com'
+    )
+  }
+}

src/git-command-manager.ts

@@ -0,0 +1,295 @@
+import * as exec from '@actions/exec'
+import * as io from '@actions/io'
+import * as utils from './utils'
+import * as path from 'path'
+
+const tagsRefSpec = '+refs/tags/*:refs/tags/*'
+
+export class GitCommandManager {
+  private gitPath: string
+  private workingDirectory: string
+  // Git options used when commands require an identity
+  private identityGitOptions?: string[]
+
+  private constructor(workingDirectory: string, gitPath: string) {
+    this.workingDirectory = workingDirectory
+    this.gitPath = gitPath
+  }
+
+  static async create(workingDirectory: string): Promise<GitCommandManager> {
+    const gitPath = await io.which('git', true)
+    return new GitCommandManager(workingDirectory, gitPath)
+  }
+
+  setIdentityGitOptions(identityGitOptions: string[]): void {
+    this.identityGitOptions = identityGitOptions
+  }
+
+  async checkout(ref: string, startPoint?: string): Promise<void> {
+    const args = ['checkout', '--progress']
+    if (startPoint) {
+      args.push('-B', ref, startPoint)
+    } else {
+      args.push(ref)
+    }
+    // https://github.com/git/git/commit/a047fafc7866cc4087201e284dc1f53e8f9a32d5
+    args.push('--')
+    await this.exec(args)
+  }
+
+  async cherryPick(
+    options?: string[],
+    allowAllExitCodes = false
+  ): Promise<GitOutput> {
+    const args = ['cherry-pick']
+    if (this.identityGitOptions) {
+      args.unshift(...this.identityGitOptions)
+    }
+
+    if (options) {
+      args.push(...options)
+    }
+
+    return await this.exec(args, allowAllExitCodes)
+  }
+
+  async commit(options?: string[]): Promise<void> {
+    const args = ['commit']
+    if (this.identityGitOptions) {
+      args.unshift(...this.identityGitOptions)
+    }
+
+    if (options) {
+      args.push(...options)
+    }
+
+    await this.exec(args)
+  }
+
+  async config(
+    configKey: string,
+    configValue: string,
+    globalConfig?: boolean
+  ): Promise<void> {
+    await this.exec([
+      'config',
+      globalConfig ? '--global' : '--local',
+      configKey,
+      configValue
+    ])
+  }
+
+  async configExists(
+    configKey: string,
+    configValue = '.',
+    globalConfig?: boolean
+  ): Promise<boolean> {
+    const output = await this.exec(
+      [
+        'config',
+        globalConfig ? '--global' : '--local',
+        '--name-only',
+        '--get-regexp',
+        configKey,
+        configValue
+      ],
+      true
+    )
+    return output.exitCode === 0
+  }
+
+  async fetch(
+    refSpec: string[],
+    remoteName?: string,
+    options?: string[]
+  ): Promise<void> {
+    const args = ['-c', 'protocol.version=2', 'fetch']
+    if (!refSpec.some(x => x === tagsRefSpec)) {
+      args.push('--no-tags')
+    }
+
+    args.push('--progress', '--no-recurse-submodules')
+    if (
+      utils.fileExistsSync(path.join(this.workingDirectory, '.git', 'shallow'))
+    ) {
+      args.push('--unshallow')
+    }
+
+    if (options) {
+      args.push(...options)
+    }
+
+    if (remoteName) {
+      args.push(remoteName)
+    } else {
+      args.push('origin')
+    }
+    for (const arg of refSpec) {
+      args.push(arg)
+    }
+
+    await this.exec(args)
+  }
+
+  async getConfigValue(configKey: string, configValue = '.'): Promise<string> {
+    const output = await this.exec([
+      'config',
+      '--local',
+      '--get-regexp',
+      configKey,
+      configValue
+    ])
+    return output.stdout.trim().split(`${configKey} `)[1]
+  }
+
+  getWorkingDirectory(): string {
+    return this.workingDirectory
+  }
+
+  async hasDiff(options?: string[]): Promise<boolean> {
+    const args = ['diff', '--quiet']
+    if (options) {
+      args.push(...options)
+    }
+    const output = await this.exec(args, true)
+    return output.exitCode === 1
+  }
+
+  async isDirty(untracked: boolean): Promise<boolean> {
+    // Check untracked changes
+    if (untracked && (await this.status(['--porcelain', '-unormal']))) {
+      return true
+    }
+    // Check working index changes
+    if (await this.hasDiff()) {
+      return true
+    }
+    // Check staged changes
+    if (await this.hasDiff(['--staged'])) {
+      return true
+    }
+    return false
+  }
+
+  async push(options?: string[]): Promise<void> {
+    const args = ['push']
+    if (options) {
+      args.push(...options)
+    }
+    await this.exec(args)
+  }
+
+  async revList(
+    commitExpression: string[],
+    options?: string[]
+  ): Promise<string> {
+    const args = ['rev-list']
+    if (options) {
+      args.push(...options)
+    }
+    args.push(...commitExpression)
+    const output = await this.exec(args)
+    return output.stdout.trim()
+  }
+
+  async revParse(ref: string, options?: string[]): Promise<string> {
+    const args = ['rev-parse']
+    if (options) {
+      args.push(...options)
+    }
+    args.push(ref)
+    const output = await this.exec(args)
+    return output.stdout.trim()
+  }
+
+  async status(options?: string[]): Promise<string> {
+    const args = ['status']
+    if (options) {
+      args.push(...options)
+    }
+    const output = await this.exec(args)
+    return output.stdout.trim()
+  }
+
+  async symbolicRef(ref: string, options?: string[]): Promise<string> {
+    const args = ['symbolic-ref', ref]
+    if (options) {
+      args.push(...options)
+    }
+    const output = await this.exec(args)
+    return output.stdout.trim()
+  }
+
+  async tryConfigUnset(
+    configKey: string,
+    configValue = '.',
+    globalConfig?: boolean
+  ): Promise<boolean> {
+    const output = await this.exec(
+      [
+        'config',
+        globalConfig ? '--global' : '--local',
+        '--unset',
+        configKey,
+        configValue
+      ],
+      true
+    )
+    return output.exitCode === 0
+  }
+
+  async tryGetRemoteUrl(): Promise<string> {
+    const output = await this.exec(
+      ['config', '--local', '--get', 'remote.origin.url'],
+      true
+    )
+
+    if (output.exitCode !== 0) {
+      return ''
+    }
+
+    const stdout = output.stdout.trim()
+    if (stdout.includes('\n')) {
+      return ''
+    }
+
+    return stdout
+  }
+
+  async exec(args: string[], allowAllExitCodes = false): Promise<GitOutput> {
+    const result = new GitOutput()
+
+    const env = {}
+    for (const key of Object.keys(process.env)) {
+      env[key] = process.env[key]
+    }
+
+    const stdout: string[] = []
+    const stderr: string[] = []
+
+    const options = {
+      cwd: this.workingDirectory,
+      env,
+      ignoreReturnCode: allowAllExitCodes,
+      listeners: {
+        stdout: (data: Buffer) => {
+          stdout.push(data.toString())
+        },
+        stderr: (data: Buffer) => {
+          stderr.push(data.toString())
+        }
+      }
+    }
+
+    result.exitCode = await exec.exec(`"${this.gitPath}"`, args, options)
+    result.stdout = stdout.join('')
+    result.stderr = stderr.join('')
+    return result
+  }
+}
+
+class GitOutput {
+  stdout = ''
+  stderr = ''
+  exitCode = 0
+}

src/github-helper.ts

@@ -0,0 +1,178 @@
+import * as core from '@actions/core'
+import {Inputs} from './create-pull-request'
+import {Octokit, OctokitOptions} from './octokit-client'
+
+const ERROR_PR_REVIEW_FROM_AUTHOR =
+  'Review cannot be requested from pull request author'
+
+interface Repository {
+  owner: string
+  repo: string
+}
+
+interface Pull {
+  number: number
+  html_url: string
+  created: boolean
+}
+
+export class GitHubHelper {
+  private octokit: InstanceType<typeof Octokit>
+
+  constructor(token: string) {
+    const options: OctokitOptions = {}
+    if (token) {
+      options.auth = `${token}`
+    }
+    options.baseUrl = process.env['GITHUB_API_URL'] || 'https://api.github.com'
+    this.octokit = new Octokit(options)
+  }
+
+  private parseRepository(repository: string): Repository {
+    const [owner, repo] = repository.split('/')
+    return {
+      owner: owner,
+      repo: repo
+    }
+  }
+
+  private async createOrUpdate(
+    inputs: Inputs,
+    baseRepository: string,
+    headBranch: string
+  ): Promise<Pull> {
+    // Try to create the pull request
+    try {
+      core.info(`Attempting creation of pull request`)
+      const {data: pull} = await this.octokit.rest.pulls.create({
+        ...this.parseRepository(baseRepository),
+        title: inputs.title,
+        head: headBranch,
+        base: inputs.base,
+        body: inputs.body,
+        draft: inputs.draft
+      })
+      core.info(
+        `Created pull request #${pull.number} (${headBranch} => ${inputs.base})`
+      )
+      return {
+        number: pull.number,
+        html_url: pull.html_url,
+        created: true
+      }
+    } catch (e: any) {
+      if (
+        e.message &&
+        e.message.includes(`A pull request already exists for ${headBranch}`)
+      ) {
+        core.info(`A pull request already exists for ${headBranch}`)
+      } else {
+        throw e
+      }
+    }
+
+    // Update the pull request that exists for this branch and base
+    core.info(`Fetching existing pull request`)
+    const {data: pulls} = await this.octokit.rest.pulls.list({
+      ...this.parseRepository(baseRepository),
+      state: 'open',
+      head: headBranch,
+      base: inputs.base
+    })
+    core.info(`Attempting update of pull request`)
+    const {data: pull} = await this.octokit.rest.pulls.update({
+      ...this.parseRepository(baseRepository),
+      pull_number: pulls[0].number,
+      title: inputs.title,
+      body: inputs.body
+    })
+    core.info(
+      `Updated pull request #${pull.number} (${headBranch} => ${inputs.base})`
+    )
+    return {
+      number: pull.number,
+      html_url: pull.html_url,
+      created: false
+    }
+  }
+
+  async getRepositoryParent(headRepository: string): Promise<string> {
+    const {data: headRepo} = await this.octokit.rest.repos.get({
+      ...this.parseRepository(headRepository)
+    })
+    if (!headRepo.parent) {
+      throw new Error(
+        `Repository '${headRepository}' is not a fork. Unable to continue.`
+      )
+    }
+    return headRepo.parent.full_name
+  }
+
+  async createOrUpdatePullRequest(
+    inputs: Inputs,
+    baseRepository: string,
+    headRepository: string
+  ): Promise<Pull> {
+    const [headOwner] = headRepository.split('/')
+    const headBranch = `${headOwner}:${inputs.branch}`
+
+    // Create or update the pull request
+    const pull = await this.createOrUpdate(inputs, baseRepository, headBranch)
+
+    // Apply milestone
+    if (inputs.milestone) {
+      core.info(`Applying milestone '${inputs.milestone}'`)
+      await this.octokit.rest.issues.update({
+        ...this.parseRepository(baseRepository),
+        issue_number: pull.number,
+        milestone: inputs.milestone
+      })
+    }
+    // Apply labels
+    if (inputs.labels.length > 0) {
+      core.info(`Applying labels '${inputs.labels}'`)
+      await this.octokit.rest.issues.addLabels({
+        ...this.parseRepository(baseRepository),
+        issue_number: pull.number,
+        labels: inputs.labels
+      })
+    }
+    // Apply assignees
+    if (inputs.assignees.length > 0) {
+      core.info(`Applying assignees '${inputs.assignees}'`)
+      await this.octokit.rest.issues.addAssignees({
+        ...this.parseRepository(baseRepository),
+        issue_number: pull.number,
+        assignees: inputs.assignees
+      })
+    }
+
+    // Request reviewers and team reviewers
+    const requestReviewersParams = {}
+    if (inputs.reviewers.length > 0) {
+      requestReviewersParams['reviewers'] = inputs.reviewers
+      core.info(`Requesting reviewers '${inputs.reviewers}'`)
+    }
+    if (inputs.teamReviewers.length > 0) {
+      requestReviewersParams['team_reviewers'] = inputs.teamReviewers
+      core.info(`Requesting team reviewers '${inputs.teamReviewers}'`)
+    }
+    if (Object.keys(requestReviewersParams).length > 0) {
+      try {
+        await this.octokit.rest.pulls.requestReviewers({
+          ...this.parseRepository(baseRepository),
+          pull_number: pull.number,
+          ...requestReviewersParams
+        })
+      } catch (e: any) {
+        if (e.message && e.message.includes(ERROR_PR_REVIEW_FROM_AUTHOR)) {
+          core.warning(ERROR_PR_REVIEW_FROM_AUTHOR)
+        } else {
+          throw e
+        }
+      }
+    }
+
+    return pull
+  }
+}

src/main.ts

@@ -0,0 +1,38 @@
+import * as core from '@actions/core'
+import {Inputs, createPullRequest} from './create-pull-request'
+import {inspect} from 'util'
+import * as utils from './utils'
+
+async function run(): Promise<void> {
+  try {
+    const inputs: Inputs = {
+      token: core.getInput('token'),
+      path: core.getInput('path'),
+      addPaths: utils.getInputAsArray('add-paths'),
+      commitMessage: core.getInput('commit-message'),
+      committer: core.getInput('committer'),
+      author: core.getInput('author'),
+      signoff: core.getInput('signoff') === 'true',
+      branch: core.getInput('branch'),
+      deleteBranch: core.getInput('delete-branch') === 'true',
+      branchSuffix: core.getInput('branch-suffix'),
+      base: core.getInput('base'),
+      pushToFork: core.getInput('push-to-fork'),
+      title: core.getInput('title'),
+      body: core.getInput('body'),
+      labels: utils.getInputAsArray('labels'),
+      assignees: utils.getInputAsArray('assignees'),
+      reviewers: utils.getInputAsArray('reviewers'),
+      teamReviewers: utils.getInputAsArray('team-reviewers'),
+      milestone: Number(core.getInput('milestone')),
+      draft: core.getInput('draft') === 'true'
+    }
+    core.debug(`Inputs: ${inspect(inputs)}`)
+
+    await createPullRequest(inputs)
+  } catch (error: any) {
+    core.setFailed(error.message)
+  }
+}
+
+run()

src/octokit-client.ts

@@ -0,0 +1,23 @@
+import {Octokit as Core} from '@octokit/core'
+import {paginateRest} from '@octokit/plugin-paginate-rest'
+import {restEndpointMethods} from '@octokit/plugin-rest-endpoint-methods'
+import {HttpsProxyAgent} from 'https-proxy-agent'
+export {RestEndpointMethodTypes} from '@octokit/plugin-rest-endpoint-methods'
+export {OctokitOptions} from '@octokit/core/dist-types/types'
+
+export const Octokit = Core.plugin(
+  paginateRest,
+  restEndpointMethods,
+  autoProxyAgent
+)
+
+// Octokit plugin to support the https_proxy environment variable
+function autoProxyAgent(octokit: Core) {
+  const proxy = process.env.https_proxy || process.env.HTTPS_PROXY
+  if (!proxy) return
+
+  const agent = new HttpsProxyAgent(proxy)
+  octokit.hook.before('request', options => {
+    options.request.agent = agent
+  })
+}

src/requirements.txt

@@ -1,2 +0,0 @@
-GitPython==3.0.7
-PyGithub==1.46

src/setup-python.js

@@ -1,52 +0,0 @@
-const core = require("@actions/core");
-const tc = require("@actions/tool-cache");
-const path = require("path");
-const semver = require("semver");
-
-/**
- * Setup for Python from the GitHub Actions tool cache
- * Converted from https://github.com/actions/setup-python
- *
- * @param {string} versionSpec version of Python
- * @param {string} arch architecture (x64|x32)
- */
-let setupPython = function(versionSpec, arch) {
-  return new Promise((resolve, reject) => {
-    const IS_WINDOWS = process.platform === "win32";
-
-    // Find the version of Python we want in the tool cache
-    const installDir = tc.find("Python", versionSpec, arch);
-    core.debug(`installDir: ${installDir}`);
-
-    // Set paths
-    core.exportVariable("pythonLocation", installDir);
-    core.addPath(installDir);
-    if (IS_WINDOWS) {
-      core.addPath(path.join(installDir, "Scripts"));
-    } else {
-      core.addPath(path.join(installDir, "bin"));
-    }
-
-    if (IS_WINDOWS) {
-      // Add --user directory
-      // `installDir` from tool cache should look like $AGENT_TOOLSDIRECTORY/Python/<semantic version>/x64/
-      // So if `findLocalTool` succeeded above, we must have a conformant `installDir`
-      const version = path.basename(path.dirname(installDir));
-      const major = semver.major(version);
-      const minor = semver.minor(version);
-
-      const userScriptsDir = path.join(
-        process.env["APPDATA"] || "",
-        "Python",
-        `Python${major}${minor}`,
-        "Scripts"
-      );
-      core.addPath(userScriptsDir);
-    }
-    // On Linux and macOS, pip will create the --user directory and add it to PATH as needed.
-
-    resolve();
-  });
-};
-
-module.exports = setupPython;

src/test_common.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-""" Test Common """
-import common as cmn
-import pytest
-
-
-def test_get_random_string():
-    assert len(cmn.get_random_string()) == 7
-    assert len(cmn.get_random_string(length=20)) == 20
-
-
-def test_parse_github_repository_success():
-    protocol, repository = cmn.parse_github_repository(
-        "https://github.com/peter-evans/create-pull-request"
-    )
-    assert protocol == "HTTPS"
-    assert repository == "peter-evans/create-pull-request"
-
-    protocol, repository = cmn.parse_github_repository(
-        "git@github.com:peter-evans/create-pull-request.git"
-    )
-    assert protocol == "SSH"
-    assert repository == "peter-evans/create-pull-request"
-
-
-def test_parse_github_repository_failure():
-    url = "https://github.com/peter-evans"
-    with pytest.raises(ValueError) as e_info:
-        cmn.parse_github_repository(url)
-    assert (
-        e_info.value.args[0]
-        == f"The format of '{url}' is not a valid GitHub repository URL"
-    )
-
-
-def test_parse_display_name_email_success():
-    name, email = cmn.parse_display_name_email("abc def <abc@def.com>")
-    assert name == "abc def"
-    assert email == "abc@def.com"
-
-    name, email = cmn.parse_display_name_email(
-        "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"
-    )
-    assert name == "github-actions[bot]"
-    assert email == "41898282+github-actions[bot]@users.noreply.github.com"
-
-
-def test_parse_display_name_email_failure():
-    display_name_email = "abc@def.com"
-    with pytest.raises(ValueError) as e_info:
-        cmn.parse_display_name_email(display_name_email)
-    assert (
-        e_info.value.args[0]
-        == f"The format of '{display_name_email}' is not a valid email address with display name"
-    )
-
-    display_name_email = " < >"
-    with pytest.raises(ValueError) as e_info:
-        cmn.parse_display_name_email(display_name_email)
-    assert (
-        e_info.value.args[0]
-        == f"The format of '{display_name_email}' is not a valid email address with display name"
-    )

src/test_create_or_update_branch.py

@@ -1,757 +0,0 @@
-#!/usr/bin/env python3
-""" Test Create or Update Branch """
-import create_or_update_branch as coub
-from git import Repo
-import os
-import pytest
-import sys
-import time
-
-
-# Set git repo
-REPO_PATH = os.getenv("COUB_REPO_PATH", os.getcwd())
-repo = Repo(REPO_PATH)
-
-# Set git environment
-author_name = "github-actions[bot]"
-author_email = "41898282+github-actions[bot]@users.noreply.github.com"
-committer_name = "GitHub"
-committer_email = "noreply@github.com"
-repo.git.update_environment(
-    GIT_AUTHOR_NAME=author_name,
-    GIT_AUTHOR_EMAIL=author_email,
-    GIT_COMMITTER_NAME=committer_name,
-    GIT_COMMITTER_EMAIL=committer_email,
-)
-
-REPO_URL = repo.git.config("--get", "remote.origin.url")
-
-TRACKED_FILE = "tracked-file.txt"
-UNTRACKED_FILE = "untracked-file.txt"
-
-DEFAULT_BRANCH = "tests/master"
-NOT_BASE_BRANCH = "tests/branch-that-is-not-the-base"
-NOT_EXIST_BRANCH = "tests/branch-that-does-not-exist"
-
-COMMIT_MESSAGE = "[create-pull-request] automated change"
-BRANCH = "tests/create-pull-request/patch"
-BASE = DEFAULT_BRANCH
-
-
-def create_tracked_change(content=None):
-    if content is None:
-        content = str(time.time())
-    # Create a tracked file change
-    with open(os.path.join(REPO_PATH, TRACKED_FILE), "w") as f:
-        f.write(content)
-    return content
-
-
-def create_untracked_change(content=None):
-    if content is None:
-        content = str(time.time())
-    # Create an untracked file change
-    with open(os.path.join(REPO_PATH, UNTRACKED_FILE), "w") as f:
-        f.write(content)
-    return content
-
-
-def get_tracked_content():
-    # Read the content of the tracked file
-    with open(os.path.join(REPO_PATH, TRACKED_FILE), "r") as f:
-        return f.read()
-
-
-def get_untracked_content():
-    # Read the content of the untracked file
-    with open(os.path.join(REPO_PATH, UNTRACKED_FILE), "r") as f:
-        return f.read()
-
-
-def create_changes(tracked_content=None, untracked_content=None):
-    tracked_content = create_tracked_change(tracked_content)
-    untracked_content = create_untracked_change(untracked_content)
-    return tracked_content, untracked_content
-
-
-def create_commits(number=2, final_tracked_content=None, final_untracked_content=None):
-    for i in range(number):
-        commit_number = i + 1
-        if commit_number == number:
-            tracked_content, untracked_content = create_changes(
-                final_tracked_content, final_untracked_content
-            )
-        else:
-            tracked_content, untracked_content = create_changes()
-        repo.git.add("-A")
-        repo.git.commit(m=f"Commit {commit_number}")
-    return tracked_content, untracked_content
-
-
-@pytest.fixture(scope="module", autouse=True)
-def before_after_all():
-    print("Before all tests")
-    # Check there are no local changes that might be
-    # destroyed by running these tests
-    assert not repo.is_dirty(untracked_files=True)
-
-    # Create a new default branch for the test run
-    repo.remotes.origin.fetch()
-    repo.git.checkout("master")
-    repo.git.checkout("HEAD", b=NOT_BASE_BRANCH)
-    create_tracked_change()
-    repo.git.add("-A")
-    repo.git.commit(m="This commit should not appear in pr branches")
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{NOT_BASE_BRANCH}")
-    # Create a new default branch for the test run
-    repo.git.checkout("master")
-    repo.git.checkout("HEAD", b=DEFAULT_BRANCH)
-    create_tracked_change()
-    repo.git.add("-A")
-    repo.git.commit(m="Add file to be a tracked file for tests")
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-
-    yield
-
-    print("After all tests")
-    repo.git.checkout("master")
-    # Delete the "not base branch" created for the test run
-    repo.git.branch("--delete", "--force", NOT_BASE_BRANCH)
-    repo.git.push("--delete", "--force", REPO_URL, f"refs/heads/{NOT_BASE_BRANCH}")
-    # Delete the default branch created for the test run
-    repo.git.branch("--delete", "--force", DEFAULT_BRANCH)
-    repo.git.push("--delete", "--force", REPO_URL, f"refs/heads/{DEFAULT_BRANCH}")
-
-
-def before_test():
-    print("Before test")
-    # Checkout the default branch
-    repo.git.checkout(DEFAULT_BRANCH)
-
-
-def after_test(delete_remote=True):
-    print("After test")
-    # Output git log
-    print(repo.git.log("-5", pretty="oneline"))
-    # Delete the pull request branch if it exists
-    repo.git.checkout(DEFAULT_BRANCH)
-    print(f"Deleting {BRANCH}")
-    for branch in repo.branches:
-        if branch.name == BRANCH:
-            repo.git.branch("--delete", "--force", BRANCH)
-            break
-    if delete_remote:
-        print(f"Deleting origin/{BRANCH}")
-        for ref in repo.remotes.origin.refs:
-            if ref.name == f"origin/{BRANCH}":
-                repo.git.push("--delete", "--force", REPO_URL, f"refs/heads/{BRANCH}")
-                repo.remotes.origin.fetch("--prune")
-                break
-
-
-@pytest.fixture(autouse=True)
-def before_after_tests():
-    before_test()
-    yield
-    after_test()
-
-
-# Tests if a branch exists and can be fetched
-def coub_fetch_successful():
-    assert coub.fetch_successful(repo, REPO_URL, NOT_BASE_BRANCH)
-    assert not coub.fetch_successful(repo, REPO_URL, NOT_EXIST_BRANCH)
-
-
-# Tests no changes resulting in no new branch being created
-def coub_no_changes_on_create():
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "none"
-
-
-# Tests create and update with a tracked file change
-def coub_tracked_changes():
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-
-
-# Tests create and update with an untracked file change
-def coub_untracked_changes():
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with identical changes
-# The pull request branch will not be updated
-def coub_identical_changes():
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create identical tracked and untracked file changes
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "none"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with commits on the base inbetween
-def coub_commits_on_base():
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and then an update with no changes
-# This effectively reverts the branch back to match the base and results in no diff
-def coub_changes_no_diff():
-    # Save the default branch tracked content
-    default_tracked_content = get_tracked_content()
-
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Running with no update effectively reverts the branch back to match the base
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == default_tracked_content
-
-
-# Tests create and update with commits on the base inbetween
-# The changes on base effectively revert the branch back to match the base and results in no diff
-def coub_commits_on_base_no_diff():
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    tracked_content, untracked_content = create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Create the same tracked and untracked file changes that were made to the base
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with commits on the working base (during the workflow)
-def coub_commits_on_working_base():
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with changes and commits on the working base (during the workflow)
-def coub_changes_and_commits_on_working_base():
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Tests create and update with changes and commits on the working base (during the workflow)
-# with commits on the base inbetween
-def coub_changes_and_commits_on_base_and_working_base():
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, None, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests no changes resulting in no new branch being created
-def coub_wbnb_no_changes_on_create():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "none"
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with a tracked file change
-def coub_wbnb_tracked_changes():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create a tracked file change
-    tracked_content = create_tracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with an untracked file change
-def coub_wbnb_untracked_changes():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create an untracked file change
-    untracked_content = create_untracked_change()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with identical changes
-# The pull request branch will not be updated
-def coub_wbnb_identical_changes():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create identical tracked and untracked file changes
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "none"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with commits on the base inbetween
-def coub_wbnb_commits_on_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and then an update with no changes
-# This effectively reverts the branch back to match the base and results in no diff
-def coub_wbnb_changes_no_diff():
-    # Save the default branch tracked content
-    default_tracked_content = get_tracked_content()
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Running with no update effectively reverts the branch back to match the base
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == default_tracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with commits on the base inbetween
-# The changes on base effectively revert the branch back to match the base and results in no diff
-# This scenario will cause cherrypick to fail due to an empty commit.
-# The commit is empty because the changes now exist on the base.
-def coub_wbnb_commits_on_base_no_diff():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    tracked_content, untracked_content = create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create the same tracked and untracked file changes that were made to the base
-    create_changes(tracked_content, untracked_content)
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"] == False
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with commits on the working base (during the workflow)
-def coub_wbnb_commits_on_working_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    tracked_content, untracked_content = create_commits()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with changes and commits on the working base (during the workflow)
-def coub_wbnb_changes_and_commits_on_working_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# Working Base is Not Base (WBNB)
-# Tests create and update with changes and commits on the working base (during the workflow)
-# with commits on the base inbetween
-def coub_wbnb_changes_and_commits_on_base_and_working_base():
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "created"
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-    # Push pull request branch to remote
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{BRANCH}")
-    repo.remotes.origin.fetch()
-
-    after_test(delete_remote=False)
-    before_test()
-
-    # Create commits on the base
-    create_commits()
-    repo.git.push("--force", REPO_URL, f"HEAD:refs/heads/{DEFAULT_BRANCH}")
-    repo.remotes.origin.fetch()
-
-    # Set the working base to a branch that is not the pull request base
-    repo.git.checkout(NOT_BASE_BRANCH)
-    # Create commits on the working base
-    create_commits()
-    # Create tracked and untracked file changes
-    tracked_content, untracked_content = create_changes()
-    result = coub.create_or_update_branch(repo, REPO_URL, COMMIT_MESSAGE, BASE, BRANCH)
-    assert result["action"] == "updated"
-    assert result["diff"]
-    assert get_tracked_content() == tracked_content
-    assert get_untracked_content() == untracked_content
-
-
-# pytest -v -s ~/git/create-pull-request/src
-
-test_coub_fetch_successful = coub_fetch_successful
-
-test_coub_no_changes_on_create = coub_no_changes_on_create
-test_coub_tracked_changes = coub_tracked_changes
-test_coub_untracked_changes = coub_untracked_changes
-test_coub_identical_changes = coub_identical_changes
-test_coub_commits_on_base = coub_commits_on_base
-
-test_coub_changes_no_diff = coub_changes_no_diff
-test_coub_commits_on_base_no_diff = coub_commits_on_base_no_diff
-
-test_coub_commits_on_working_base = coub_commits_on_working_base
-test_coub_changes_and_commits_on_working_base = coub_changes_and_commits_on_working_base
-test_coub_changes_and_commits_on_base_and_working_base = (
-    coub_changes_and_commits_on_base_and_working_base
-)
-
-# WBNB
-test_coub_wbnb_no_changes_on_create = coub_wbnb_no_changes_on_create
-test_coub_wbnb_tracked_changes = coub_wbnb_tracked_changes
-test_coub_wbnb_untracked_changes = coub_wbnb_untracked_changes
-test_coub_wbnb_identical_changes = coub_wbnb_identical_changes
-test_coub_wbnb_commits_on_base = coub_wbnb_commits_on_base
-
-test_coub_wbnb_changes_no_diff = coub_wbnb_changes_no_diff
-test_coub_wbnb_commits_on_base_no_diff = coub_wbnb_commits_on_base_no_diff
-
-test_coub_wbnb_commits_on_working_base = coub_wbnb_commits_on_working_base
-test_coub_wbnb_changes_and_commits_on_working_base = (
-    coub_wbnb_changes_and_commits_on_working_base
-)
-test_coub_wbnb_changes_and_commits_on_base_and_working_base = (
-    coub_wbnb_changes_and_commits_on_base_and_working_base
-)

src/utils.ts

@@ -0,0 +1,152 @@
+import * as core from '@actions/core'
+import * as fs from 'fs'
+import * as path from 'path'
+
+export function getInputAsArray(
+  name: string,
+  options?: core.InputOptions
+): string[] {
+  return getStringAsArray(core.getInput(name, options))
+}
+
+export function getStringAsArray(str: string): string[] {
+  return str
+    .split(/[\n,]+/)
+    .map(s => s.trim())
+    .filter(x => x !== '')
+}
+
+export function getRepoPath(relativePath?: string): string {
+  let githubWorkspacePath = process.env['GITHUB_WORKSPACE']
+  if (!githubWorkspacePath) {
+    throw new Error('GITHUB_WORKSPACE not defined')
+  }
+  githubWorkspacePath = path.resolve(githubWorkspacePath)
+  core.debug(`githubWorkspacePath: ${githubWorkspacePath}`)
+
+  let repoPath = githubWorkspacePath
+  if (relativePath) repoPath = path.resolve(repoPath, relativePath)
+
+  core.debug(`repoPath: ${repoPath}`)
+  return repoPath
+}
+
+interface RemoteDetail {
+  protocol: string
+  repository: string
+}
+
+export function getRemoteDetail(remoteUrl: string): RemoteDetail {
+  // Parse the protocol and github repository from a URL
+  // e.g. HTTPS, peter-evans/create-pull-request
+  const githubUrl = process.env['GITHUB_SERVER_URL'] || 'https://github.com'
+
+  const githubServerMatch = githubUrl.match(/^https?:\/\/(.+)$/i)
+  if (!githubServerMatch) {
+    throw new Error('Could not parse GitHub Server name')
+  }
+
+  const httpsUrlPattern = new RegExp(
+    '^https?://.*@?' + githubServerMatch[1] + '/(.+/.+)$',
+    'i'
+  )
+  const sshUrlPattern = new RegExp(
+    '^git@' + githubServerMatch[1] + ':(.+/.+).git$',
+    'i'
+  )
+
+  const httpsMatch = remoteUrl.match(httpsUrlPattern)
+  if (httpsMatch) {
+    return {
+      protocol: 'HTTPS',
+      repository: httpsMatch[1]
+    }
+  }
+
+  const sshMatch = remoteUrl.match(sshUrlPattern)
+  if (sshMatch) {
+    return {
+      protocol: 'SSH',
+      repository: sshMatch[1]
+    }
+  }
+
+  throw new Error(
+    `The format of '${remoteUrl}' is not a valid GitHub repository URL`
+  )
+}
+
+export function getRemoteUrl(protocol: string, repository: string): string {
+  return protocol == 'HTTPS'
+    ? `https://github.com/${repository}`
+    : `git@github.com:${repository}.git`
+}
+
+export function secondsSinceEpoch(): number {
+  const now = new Date()
+  return Math.round(now.getTime() / 1000)
+}
+
+export function randomString(): string {
+  return Math.random().toString(36).substr(2, 7)
+}
+
+interface DisplayNameEmail {
+  name: string
+  email: string
+}
+
+export function parseDisplayNameEmail(
+  displayNameEmail: string
+): DisplayNameEmail {
+  // Parse the name and email address from a string in the following format
+  // Display Name <email@address.com>
+  const pattern = /^([^<]+)\s*<([^>]+)>$/i
+
+  // Check we have a match
+  const match = displayNameEmail.match(pattern)
+  if (!match) {
+    throw new Error(
+      `The format of '${displayNameEmail}' is not a valid email address with display name`
+    )
+  }
+
+  // Check that name and email are not just whitespace
+  const name = match[1].trim()
+  const email = match[2].trim()
+  if (!name || !email) {
+    throw new Error(
+      `The format of '${displayNameEmail}' is not a valid email address with display name`
+    )
+  }
+
+  return {
+    name: name,
+    email: email
+  }
+}
+
+export function fileExistsSync(path: string): boolean {
+  if (!path) {
+    throw new Error("Arg 'path' must not be empty")
+  }
+
+  let stats: fs.Stats
+  try {
+    stats = fs.statSync(path)
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      return false
+    }
+
+    throw new Error(
+      `Encountered an error when checking whether path '${path}' exists: ${error.message}`
+    )
+  }
+
+  if (!stats.isDirectory()) {
+    return true
+  }
+
+  return false
+}

tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "lib": [
+      "es6"
+    ],
+    "outDir": "./lib",
+    "rootDir": "./src",
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "esModuleInterop": true
+  },
+  "exclude": ["__test__", "lib", "node_modules"]
+}