[devdocsgjs/main: 1444/1867] Update Git documentation (2.30.0)
- From: Andy Holmes <andyholmes src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [devdocsgjs/main: 1444/1867] Update Git documentation (2.30.0)
- Date: Fri, 19 Nov 2021 23:48:03 +0000 (UTC)
commit 3600a9ff3b67f04e9feb7ef969b87a857e48710e
Author: Simon Legner <Simon Legner gmail com>
Date: Sun Jan 3 08:31:48 2021 +0100
Update Git documentation (2.30.0)
lib/docs/scrapers/git.rb | 2 +-
.../fast-json-stable-stringify/.github/FUNDING.yml | 1 +
node_modules/flatted/.github/FUNDING.yml | 8 +
node_modules/is-core-module/.github/FUNDING.yml | 12 +
.../is-core-module/.github/workflows/node-4+.yml | 54 +
.../is-core-module/.github/workflows/node-iojs.yml | 58 +
.../.github/workflows/node-pretest.yml | 26 +
.../is-core-module/.github/workflows/node-zero.yml | 58 +
.../is-core-module/.github/workflows/rebase.yml | 15 +
.../.github/workflows/require-allow-edits.yml | 14 +
node_modules/resolve/.github/workflows/node-4+.yml | 54 +
.../resolve/.github/workflows/node-iojs.yml | 55 +
.../resolve/.github/workflows/node-pretest.yml | 27 +
.../resolve/.github/workflows/node-zero.yml | 55 +
node_modules/resolve/.github/workflows/rebase.yml | 15 +
.../.github/workflows/require-allow-edits.yml | 14 +
.../resolver/symlinked/_/symlink_target/.gitkeep | 0
node_modules/simple-git/LICENSE | 20 +
node_modules/simple-git/package.json | 74 +
node_modules/simple-git/promise.d.ts | 576 +++++++
node_modules/simple-git/promise.js | 96 ++
node_modules/simple-git/readme.md | 380 +++++
node_modules/simple-git/src/git.js | 1592 ++++++++++++++++++++
node_modules/simple-git/src/index.js | 14 +
.../src/responses/BranchDeleteSummary.js | 26 +
.../simple-git/src/responses/BranchSummary.js | 52 +
.../simple-git/src/responses/CommitSummary.js | 60 +
.../simple-git/src/responses/DiffSummary.js | 92 ++
.../simple-git/src/responses/FetchSummary.js | 55 +
.../simple-git/src/responses/FileStatusSummary.js | 22 +
.../simple-git/src/responses/ListLogSummary.js | 72 +
.../simple-git/src/responses/MergeSummary.js | 103 ++
.../simple-git/src/responses/MoveSummary.js | 32 +
.../simple-git/src/responses/PullSummary.js | 137 ++
.../simple-git/src/responses/StatusSummary.js | 188 +++
node_modules/simple-git/src/responses/TagList.js | 50 +
node_modules/simple-git/src/responses/index.js | 15 +
node_modules/simple-git/src/util/deferred.js | 10 +
node_modules/simple-git/src/util/dependencies.js | 12 +
node_modules/simple-git/src/util/exists.js | 33 +
node_modules/simple-git/typings/response.d.ts | 220 +++
41 files changed, 4398 insertions(+), 1 deletion(-)
---
diff --git a/lib/docs/scrapers/git.rb b/lib/docs/scrapers/git.rb
index abd2d9c4..2eca690a 100644
--- a/lib/docs/scrapers/git.rb
+++ b/lib/docs/scrapers/git.rb
@@ -1,7 +1,7 @@
module Docs
class Git < UrlScraper
self.type = 'git'
- self.release = '2.29.2'
+ self.release = '2.30.0'
self.base_url = 'https://git-scm.com/docs'
self.initial_paths = %w(/git.html)
self.links = {
diff --git a/node_modules/fast-json-stable-stringify/.github/FUNDING.yml
b/node_modules/fast-json-stable-stringify/.github/FUNDING.yml
new file mode 100644
index 00000000..61f9daa9
--- /dev/null
+++ b/node_modules/fast-json-stable-stringify/.github/FUNDING.yml
@@ -0,0 +1 @@
+tidelift: "npm/fast-json-stable-stringify"
diff --git a/node_modules/flatted/.github/FUNDING.yml b/node_modules/flatted/.github/FUNDING.yml
new file mode 100644
index 00000000..d53abd3b
--- /dev/null
+++ b/node_modules/flatted/.github/FUNDING.yml
@@ -0,0 +1,8 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # not working due missing www.
+open_collective: #
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+custom: https://www.patreon.com/webreflection
diff --git a/node_modules/is-core-module/.github/FUNDING.yml b/node_modules/is-core-module/.github/FUNDING.yml
new file mode 100644
index 00000000..422ce9b0
--- /dev/null
+++ b/node_modules/is-core-module/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/is-core-module
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
diff --git a/node_modules/is-core-module/.github/workflows/node-4+.yml
b/node_modules/is-core-module/.github/workflows/node-4+.yml
new file mode 100644
index 00000000..ba174e1d
--- /dev/null
+++ b/node_modules/is-core-module/.github/workflows/node-4+.yml
@@ -0,0 +1,54 @@
+name: 'Tests: node.js'
+
+on: [pull_request, push]
+
+jobs:
+ matrix:
+ runs-on: ubuntu-latest
+ outputs:
+ latest: ${{ steps.set-matrix.outputs.requireds }}
+ minors: ${{ steps.set-matrix.outputs.optionals }}
+ steps:
+ - uses: ljharb/actions/node/matrix@main
+ id: set-matrix
+ with:
+ preset: '>=4'
+
+ latest:
+ needs: [matrix]
+ name: 'latest minors'
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run tests-only'
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ minors:
+ needs: [matrix, latest]
+ name: 'non-latest minors'
+ continue-on-error: true
+ if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+
+ node:
+ name: 'node 4+'
+ needs: [latest, minors]
+ runs-on: ubuntu-latest
+ steps:
+ - run: 'echo tests completed'
diff --git a/node_modules/is-core-module/.github/workflows/node-iojs.yml
b/node_modules/is-core-module/.github/workflows/node-iojs.yml
new file mode 100644
index 00000000..f707c3cf
--- /dev/null
+++ b/node_modules/is-core-module/.github/workflows/node-iojs.yml
@@ -0,0 +1,58 @@
+name: 'Tests: node.js (io.js)'
+
+on: [pull_request, push]
+
+jobs:
+ matrix:
+ runs-on: ubuntu-latest
+ outputs:
+ latest: ${{ steps.set-matrix.outputs.requireds }}
+ minors: ${{ steps.set-matrix.outputs.optionals }}
+ steps:
+ - uses: ljharb/actions/node/matrix@main
+ id: set-matrix
+ with:
+ preset: 'iojs'
+
+ latest:
+ needs: [matrix]
+ name: 'latest minors'
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run tests-only'
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ skip-ls-check: true
+
+ minors:
+ needs: [matrix, latest]
+ name: 'non-latest minors'
+ continue-on-error: true
+ if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run tests-only'
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ skip-ls-check: true
+
+ node:
+ name: 'io.js'
+ needs: [latest, minors]
+ runs-on: ubuntu-latest
+ steps:
+ - run: 'echo tests completed'
diff --git a/node_modules/is-core-module/.github/workflows/node-pretest.yml
b/node_modules/is-core-module/.github/workflows/node-pretest.yml
new file mode 100644
index 00000000..3921e0ae
--- /dev/null
+++ b/node_modules/is-core-module/.github/workflows/node-pretest.yml
@@ -0,0 +1,26 @@
+name: 'Tests: pretest/posttest'
+
+on: [pull_request, push]
+
+jobs:
+ pretest:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run pretest'
+ with:
+ node-version: 'lts/*'
+ command: 'pretest'
+
+ posttest:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run posttest'
+ with:
+ node-version: 'lts/*'
+ command: 'posttest'
diff --git a/node_modules/is-core-module/.github/workflows/node-zero.yml
b/node_modules/is-core-module/.github/workflows/node-zero.yml
new file mode 100644
index 00000000..d044c603
--- /dev/null
+++ b/node_modules/is-core-module/.github/workflows/node-zero.yml
@@ -0,0 +1,58 @@
+name: 'Tests: node.js (0.x)'
+
+on: [pull_request, push]
+
+jobs:
+ matrix:
+ runs-on: ubuntu-latest
+ outputs:
+ stable: ${{ steps.set-matrix.outputs.requireds }}
+ unstable: ${{ steps.set-matrix.outputs.optionals }}
+ steps:
+ - uses: ljharb/actions/node/matrix@main
+ id: set-matrix
+ with:
+ preset: '0.x'
+
+ stable:
+ needs: [matrix]
+ name: 'stable minors'
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.stable) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id
}}
+ skip-ls-check: true
+
+ unstable:
+ needs: [matrix, stable]
+ name: 'unstable minors'
+ continue-on-error: true
+ if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.unstable) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id
}}
+ skip-ls-check: true
+
+ node:
+ name: 'node 0.x'
+ needs: [stable, unstable]
+ runs-on: ubuntu-latest
+ steps:
+ - run: 'echo tests completed'
diff --git a/node_modules/is-core-module/.github/workflows/rebase.yml
b/node_modules/is-core-module/.github/workflows/rebase.yml
new file mode 100644
index 00000000..0c2ad39b
--- /dev/null
+++ b/node_modules/is-core-module/.github/workflows/rebase.yml
@@ -0,0 +1,15 @@
+name: Automatic Rebase
+
+on: [pull_request_target]
+
+jobs:
+ _:
+ name: "Automatic Rebase"
+
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v1
+ - uses: ljharb/rebase@master
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/node_modules/is-core-module/.github/workflows/require-allow-edits.yml
b/node_modules/is-core-module/.github/workflows/require-allow-edits.yml
new file mode 100644
index 00000000..aac42d3e
--- /dev/null
+++ b/node_modules/is-core-module/.github/workflows/require-allow-edits.yml
@@ -0,0 +1,14 @@
+name: Require “Allow Edits”
+
+on: [pull_request_target]
+
+jobs:
+ _:
+ name: "Require “Allow Edits”"
+
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: ljharb/require-allow-edits@main
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/node_modules/resolve/.github/workflows/node-4+.yml
b/node_modules/resolve/.github/workflows/node-4+.yml
new file mode 100644
index 00000000..ba174e1d
--- /dev/null
+++ b/node_modules/resolve/.github/workflows/node-4+.yml
@@ -0,0 +1,54 @@
+name: 'Tests: node.js'
+
+on: [pull_request, push]
+
+jobs:
+ matrix:
+ runs-on: ubuntu-latest
+ outputs:
+ latest: ${{ steps.set-matrix.outputs.requireds }}
+ minors: ${{ steps.set-matrix.outputs.optionals }}
+ steps:
+ - uses: ljharb/actions/node/matrix@main
+ id: set-matrix
+ with:
+ preset: '>=4'
+
+ latest:
+ needs: [matrix]
+ name: 'latest minors'
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run tests-only'
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ minors:
+ needs: [matrix, latest]
+ name: 'non-latest minors'
+ continue-on-error: true
+ if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+
+ node:
+ name: 'node 4+'
+ needs: [latest, minors]
+ runs-on: ubuntu-latest
+ steps:
+ - run: 'echo tests completed'
diff --git a/node_modules/resolve/.github/workflows/node-iojs.yml
b/node_modules/resolve/.github/workflows/node-iojs.yml
new file mode 100644
index 00000000..a813bfd2
--- /dev/null
+++ b/node_modules/resolve/.github/workflows/node-iojs.yml
@@ -0,0 +1,55 @@
+name: 'Tests: node.js (io.js)'
+
+on: [pull_request, push]
+
+jobs:
+ matrix:
+ runs-on: ubuntu-latest
+ outputs:
+ latest: ${{ steps.set-matrix.outputs.requireds }}
+ minors: ${{ steps.set-matrix.outputs.optionals }}
+ steps:
+ - uses: ljharb/actions/node/matrix@main
+ id: set-matrix
+ with:
+ preset: 'iojs'
+
+ latest:
+ needs: [matrix]
+ name: 'latest minors'
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run tests-only'
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ minors:
+ needs: [matrix, latest]
+ name: 'non-latest minors'
+ continue-on-error: true
+ if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run tests-only'
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+
+ node:
+ name: 'io.js'
+ needs: [latest, minors]
+ runs-on: ubuntu-latest
+ steps:
+ - run: 'echo tests completed'
diff --git a/node_modules/resolve/.github/workflows/node-pretest.yml
b/node_modules/resolve/.github/workflows/node-pretest.yml
new file mode 100644
index 00000000..9ed76615
--- /dev/null
+++ b/node_modules/resolve/.github/workflows/node-pretest.yml
@@ -0,0 +1,27 @@
+name: 'Tests: pretest/posttest'
+
+on: [pull_request, push]
+
+jobs:
+ pretest:
+ runs-on: ubuntu-latest
+
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run pretest'
+ with:
+ node-version: 'lts/*'
+ command: 'pretest'
+
+ posttest:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ name: 'npm install && npm run posttest'
+ with:
+ node-version: 'lts/*'
+ command: 'posttest'
diff --git a/node_modules/resolve/.github/workflows/node-zero.yml
b/node_modules/resolve/.github/workflows/node-zero.yml
new file mode 100644
index 00000000..4b4f7f0f
--- /dev/null
+++ b/node_modules/resolve/.github/workflows/node-zero.yml
@@ -0,0 +1,55 @@
+name: 'Tests: node.js (0.x)'
+
+on: [pull_request, push]
+
+jobs:
+ matrix:
+ runs-on: ubuntu-latest
+ outputs:
+ stable: ${{ steps.set-matrix.outputs.requireds }}
+ unstable: ${{ steps.set-matrix.outputs.optionals }}
+ steps:
+ - uses: ljharb/actions/node/matrix@main
+ id: set-matrix
+ with:
+ preset: '0.x'
+
+ stable:
+ needs: [matrix]
+ name: 'stable minors'
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.stable) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id
}}
+ unstable:
+ needs: [matrix, stable]
+ name: 'unstable minors'
+ continue-on-error: true
+ if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix: ${{ fromJson(needs.matrix.outputs.unstable) }}
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/actions/node/run@main
+ with:
+ node-version: ${{ matrix.node-version }}
+ command: 'tests-only'
+ cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id
}}
+
+ node:
+ name: 'node 0.x'
+ needs: [stable, unstable]
+ runs-on: ubuntu-latest
+ steps:
+ - run: 'echo tests completed'
diff --git a/node_modules/resolve/.github/workflows/rebase.yml
b/node_modules/resolve/.github/workflows/rebase.yml
new file mode 100644
index 00000000..027aed07
--- /dev/null
+++ b/node_modules/resolve/.github/workflows/rebase.yml
@@ -0,0 +1,15 @@
+name: Automatic Rebase
+
+on: [pull_request_target]
+
+jobs:
+ _:
+ name: "Automatic Rebase"
+
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: ljharb/rebase@master
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/node_modules/resolve/.github/workflows/require-allow-edits.yml
b/node_modules/resolve/.github/workflows/require-allow-edits.yml
new file mode 100644
index 00000000..aac42d3e
--- /dev/null
+++ b/node_modules/resolve/.github/workflows/require-allow-edits.yml
@@ -0,0 +1,14 @@
+name: Require “Allow Edits”
+
+on: [pull_request_target]
+
+jobs:
+ _:
+ name: "Require “Allow Edits”"
+
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: ljharb/require-allow-edits@main
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/node_modules/resolve/test/resolver/symlinked/_/symlink_target/.gitkeep
b/node_modules/resolve/test/resolver/symlinked/_/symlink_target/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/node_modules/simple-git/LICENSE b/node_modules/simple-git/LICENSE
new file mode 100644
index 00000000..b123c04b
--- /dev/null
+++ b/node_modules/simple-git/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Steve King
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/simple-git/package.json b/node_modules/simple-git/package.json
new file mode 100644
index 00000000..655cb114
--- /dev/null
+++ b/node_modules/simple-git/package.json
@@ -0,0 +1,74 @@
+{
+ "_from": "simple-git@^1.70.0",
+ "_id": "simple-git@1.132.0",
+ "_inBundle": false,
+ "_integrity":
"sha512-xauHm1YqCTom1sC9eOjfq3/9RKiUA9iPnxBbrY2DdL8l4ADMu0jjM5l5lphQP5YWNqAL2aXC/OeuQ76vHtW5fg==",
+ "_location": "/simple-git",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "simple-git@^1.70.0",
+ "name": "simple-git",
+ "escapedName": "simple-git",
+ "rawSpec": "^1.70.0",
+ "saveSpec": null,
+ "fetchSpec": "^1.70.0"
+ },
+ "_requiredBy": [
+ "/bulk-decaffeinate"
+ ],
+ "_resolved": "https://registry.npmjs.org/simple-git/-/simple-git-1.132.0.tgz";,
+ "_shasum": "53ac4c5ec9e74e37c2fd461e23309f22fcdf09b1",
+ "_spec": "simple-git@^1.70.0",
+ "_where": "/home/simon/src/devdocs/node_modules/bulk-decaffeinate",
+ "author": {
+ "name": "Steve King",
+ "email": "steve mydev co"
+ },
+ "bugs": {
+ "url": "https://github.com/steveukx/git-js/issues";
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "name": "Steve King",
+ "email": "steve mydev co"
+ }
+ ],
+ "dependencies": {
+ "debug": "^4.0.1"
+ },
+ "deprecated": false,
+ "description": "Simple GIT interface for node.js",
+ "devDependencies": {
+ "@kwsites/test-runner": "^0.1.1",
+ "sinon": "^7.3.2"
+ },
+ "files": [
+ "promise.*",
+ "src/",
+ "typings/"
+ ],
+ "homepage": "https://github.com/steveukx/git-js#readme";,
+ "keywords": [
+ "git",
+ "source control",
+ "vcs"
+ ],
+ "license": "MIT",
+ "main": "./src/index.js",
+ "name": "simple-git",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/steveukx/git-js.git"
+ },
+ "scripts": {
+ "postversion": "npm publish && git push && git push --tags",
+ "preversion": "yarn test",
+ "test": "runner test/**/test*.js ",
+ "test:integration": "runner test/integration/test*.js",
+ "test:unit": "runner test/unit/test*.js"
+ },
+ "version": "1.132.0"
+}
diff --git a/node_modules/simple-git/promise.d.ts b/node_modules/simple-git/promise.d.ts
new file mode 100644
index 00000000..38d07f56
--- /dev/null
+++ b/node_modules/simple-git/promise.d.ts
@@ -0,0 +1,576 @@
+import * as resp from "./typings/response";
+
+declare function simplegit(basePath?: string): simplegit.SimpleGit;
+
+declare namespace simplegit {
+
+ interface SimpleGit {
+ /**
+ * Adds one or more files to source control
+ *
+ * @param {string|string[]} files
+ * @returns {Promise<void>}
+ */
+ add(files: string | string[]): Promise<void>;
+
+ /**
+ * Add an annotated tag to the head of the current branch
+ *
+ * @param {string} tagName
+ * @param {string} tagMessage
+ * @returns {Promise<void>}
+ */
+ addAnnotatedTag(tagName: string, tagMessage: string): Promise<void>;
+
+ /**
+ * Add config to local git instance
+ *
+ * @param {string} key configuration key (e.g user.name)
+ * @param {string} value for the given key (e.g your name)
+ * @returns {Promise<string>}
+ */
+ addConfig(key: string, value: string): Promise<string>;
+
+ /**
+ * Adds a remote to the list of remotes.
+ *
+ * @param {string} remoteName Name of the repository - eg "upstream"
+ * @param {string} remoteRepo Fully qualified SSH or HTTP(S) path to the remote repo
+ * @returns {Promise<void>}
+ */
+ addRemote(remoteName: string, remoteRepo: string): Promise<void>;
+
+ /**
+ * Add a lightweight tag to the head of the current branch
+ *
+ * @param {string} name
+ * @returns {Promise<string>}
+ */
+ addTag(name: string): Promise<string>;
+
+ /**
+ * Equivalent to `catFile` but will return the native `Buffer` of content from the git command's
stdout.
+ *
+ * @param {string[]} options
+ */
+ binaryCatFile(options: string[]): Promise<any>;
+
+ /**
+ * List all branches
+ */
+ branch(): Promise<BranchSummary>;
+ branch(options: Options | string[]): Promise<BranchSummary>;
+
+ /**
+ * List of local branches
+ *
+ * @returns {Promise<BranchSummary>}
+ */
+ branchLocal(): Promise<BranchSummary>;
+
+ /**
+ * Returns a list of objects in a tree based on commit hash.
+ * Passing in an object hash returns the object's content, size, and type.
+ *
+ * Passing "-p" will instruct cat-file to determine the object type, and display its formatted
contents.
+ *
+ * @param {string[]} [options]
+ * @returns {Promise<string>}
+ *
+ * @see https://git-scm.com/docs/git-cat-file
+ */
+ catFile(options: string[]): Promise<string>;
+
+ /**
+ * Check if a pathname or pathnames are excluded by .gitignore
+ *
+ * @param {string|string[]} pathnames
+ */
+ checkIgnore(pathnames: string[]): Promise<string[]>;
+
+ checkIgnore(path: string): Promise<string[]>;
+
+ /**
+ * Validates that the current repo is a Git repo.
+ *
+ * @returns {Promise<boolean>}
+ */
+ checkIsRepo(): Promise<boolean>;
+
+ /**
+ * Checkout a tag or revision, any number of additional arguments can be passed to the `git* checkout`
command
+ by supplying either a string or array of strings as the `what` parameter.
+ *
+ * @param {(string | string[])} what one or more commands to pass to `git checkout`.
+ * @returns {Promise<void>}
+ */
+ checkout(what: string | string[]): Promise<void>;
+
+ /**
+ * Checkout a remote branch.
+ *
+ * @param {string} branchName name of branch.
+ * @param {string} startPoint (e.g origin/development).
+ * @returns {Promise<void>}
+ */
+ checkoutBranch(branchName: string, startPoint: string): Promise<void>;
+
+ /**
+ * Internally uses pull and tags to get the list of tags then checks out the latest tag.
+ */
+ checkoutLatestTag(branchName: string, startPoint: string): Promise<void>;
+
+ /**
+ * Checkout a local branch
+ *
+ * @param {string} branchName name of branch.
+ * @returns {Promise<void>}
+ */
+ checkoutLocalBranch(branchName: string): Promise<void>;
+
+ /**
+ * @param {string} mode Required parameter "n" or "f"
+ * @param {string[]} options
+ */
+ clean(
+ mode: 'd' | 'f' | 'i' | 'n' | 'q' | 'x' | 'X',
+ options?: string[]
+ ): Promise<string>;
+
+ /**
+ * Clears the queue of pending commands and returns the wrapper instance for chaining.
+ */
+ clearQueue(): this;
+
+ /**
+ * Clone a repository into a new directory.
+ *
+ * @param {string} repoPath repository url to clone e.g. https://github.com/steveukx/git-js.git
+ * @param {string} localPath local folder path to clone to.
+ * @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-clone).
+ * @returns {Promise<void>}
+ */
+ clone(repoPath: string, localPath: string, options?: Options | string[]): Promise<string>;
+ clone(repoPath: string, options?: Options | string[]): Promise<string>;
+
+ /**
+ * Commits changes in the current working directory - when specific file paths are supplied, only
changes on those
+ * files will be committed.
+ *
+ * @param {string|string[]} message
+ * @param {string|string[]} [files]
+ * @param {Object} [options]
+ */
+ commit(
+ message: string | string[],
+ files?: string | string[],
+ options?: Options
+ ): Promise<resp.CommitSummary>;
+
+ /**
+ * Sets the path to a custom git binary, should either be `git` when there is an installation of git
available on
+ * the system path, or a fully qualified path to the executable.
+ *
+ * @param {string} command
+ */
+ customBinary(command: string): this;
+
+ /**
+ * Sets the working directory of the subsequent commands.
+ *
+ * @param {string} workingDirectory
+ */
+ cwd<path extends string>(workingDirectory: path): Promise<path>;
+
+ /**
+ * Delete a local branch
+ *
+ * @param {string} branchName name of branch
+ */
+ deleteLocalBranch(branchName: string):
+ Promise<resp.BranchDeletionSummary>;
+
+ /**
+ * Get the diff of the current repo compared to the last commit with a set of options supplied as a
string.
+ *
+ * @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-diff).
+ * @returns {Promise<string>} raw string result.
+ */
+ diff(options?: string[]): Promise<string>;
+
+ /**
+ * Gets a summary of the diff for files in the repo, uses the `git diff --stat` format to calculate
changes.
+ *
+ * in order to get staged (only): `--cached` or `--staged`.
+ *
+ * @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-diff).
+ * @returns {Promise<DiffResult>} Parsed diff summary result.
+ */
+ diffSummary(options?: string[]): Promise<DiffResult>;
+
+ /**
+ * Sets an environment variable for the spawned child process, either supply both a name and value as
strings or
+ * a single object to entirely replace the current environment variables.
+ *
+ * @param {string|Object} name
+ * @param {string} [value]
+ */
+ env(name: string, value: string): this;
+
+ env(env: object): this;
+
+ /**
+ * Updates the local working copy database with changes from the default remote repo and branch.
+ *
+ * @param {string | string[]} [remote] remote to fetch from.
+ * @param {string} [branch] branch to fetch from.
+ * @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-fetch).
+ * @returns {Promise<FetchResult>} Parsed fetch result.
+ */
+ fetch(remote?: string | string[], branch?: string, options?: Options): Promise<FetchResult>;
+
+ /**
+ * Gets the currently available remotes, setting the optional verbose argument to true includes
additional
+ * detail on the remotes themselves.
+ *
+ * @param {boolean} [verbose=false]
+ */
+ getRemotes(verbose: false | undefined): Promise<resp.RemoteWithoutRefs[]>;
+
+ getRemotes(verbose: true): Promise<resp.RemoteWithRefs[]>;
+
+ /**
+ * Initialize a git repo
+ *
+ * @param {Boolean} [bare=false]
+ */
+ init(bare?: boolean): Promise<void>;
+
+ /**
+ * List remote
+ *
+ * @param {string[]} [args]
+ */
+ listRemote(args: string[]): Promise<string>;
+
+ /**
+ * Show commit logs from `HEAD` to the first commit.
+ * If provided between `options.from` and `options.to` tags or branch.
+ *
+ * You can provide `options.file`, which is the path to a file in your repository. Then only this file
will be considered.
+ *
+ * To use a custom splitter in the log format, set `options.splitter` to be the string the log should
be split on.
+ *
+ * By default the following fields will be part of the result:
+ * `hash`: full commit hash
+ * `date`: author date, ISO 8601-like format
+ * `message`: subject + ref names, like the --decorate option of git-log
+ * `author_name`: author name
+ * `author_email`: author mail
+ * You can specify `options.format` to be an mapping from key to a format option like `%H` (for commit
hash).
+ * The fields specified in `options.format` will be the fields in the result.
+ *
+ * Options can also be supplied as a standard options object for adding custom properties supported by
the git log command.
+ * For any other set of options, supply options as an array of strings to be appended to the git log
command.
+ *
+ * @param {LogOptions} [options]
+ *
+ * @returns Promise<ListLogSummary>
+ *
+ * @see https://git-scm.com/docs/git-log
+ */
+ log<T = resp.DefaultLogFields>(options?: LogOptions<T>): Promise<resp.ListLogSummary<T>>;
+
+ /**
+ * Runs a merge, `options` can be either an array of arguments
+ * supported by the [`git merge`](https://git-scm.com/docs/git-merge)
+ * or an options object.
+ *
+ * Conflicts during the merge result in an error response,
+ * the response type whether it was an error or success will be a MergeSummary instance.
+ * When successful, the MergeSummary has all detail from a the PullSummary
+ *
+ * @param {Options | string[]} [options] options supported by
[git](https://git-scm.com/docs/git-merge).
+ * @returns {Promise<any>}
+ *
+ * @see https://github.com/steveukx/git-js/blob/master/src/responses/MergeSummary.js
+ * @see https://github.com/steveukx/git-js/blob/master/src/responses/PullSummary.js
+ */
+ merge(options: Options | string[]): Promise<MergeSummary>;
+
+ /**
+ * Merges from one branch to another, equivalent to running `git merge ${from} $[to}`, the `options`
argument can
+ * either be an array of additional parameters to pass to the command or null / omitted to be ignored.
+ *
+ * @param {string} from branch to merge from.
+ * @param {string} to branch to merge to.
+ * @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-merge).
+ * @returns {Promise<string>}
+ */
+ mergeFromTo(from: string, to: string, options?: string[]): Promise<string>;
+
+ /**
+ * Mirror a git repo
+ *
+ * @param {string} repoPath
+ * @param {string} localPath
+ */
+ mirror(repoPath: string, localPath: string): Promise<string>;
+
+ /**
+ * Moves one or more files to a new destination.
+ *
+ * @see https://git-scm.com/docs/git-mv
+ *
+ * @param {string|string[]} from
+ * @param {string} to
+ */
+ mv(from: string | string[], to: string): Promise<resp.MoveSummary>;
+
+ /**
+ * Sets a handler function to be called whenever a new child process is created, the handler function
will be called
+ * with the name of the command being run and the stdout & stderr streams used by the ChildProcess.
+ *
+ * @example
+ * require('simple-git')
+ * .outputHandler(function (command, stdout, stderr) {
+ * stdout.pipe(process.stdout);
+ * })
+ * .checkout('https://github.com/user/repo.git');
+ *
+ * @see https://nodejs.org/api/child_process.html#child_process_class_childprocess
+ * @see https://nodejs.org/api/stream.html#stream_class_stream_readable
+ * @param {Function} outputHandler
+ */
+ outputHandler(handler: outputHandler | void): this;
+
+ /**
+ * Fetch from and integrate with another repository or a local branch.
+ *
+ * @param {string} [remote] remote to pull from.
+ * @param {string} [branch] branch to pull from.
+ * @param {Options} [options] options supported by [git](https://git-scm.com/docs/git-pull).
+ * @returns {Promise<PullResult>} Parsed pull result.
+ */
+ pull(remote?: string, branch?: string, options?: Options): Promise<PullResult>;
+
+ /**
+ * Update remote refs along with associated objects.
+ *
+ * @param {string} [remote] remote to push to.
+ * @param {string} [branch] branch to push to.
+ * @param {Options} [options] options supported by [git](https://git-scm.com/docs/git-push).
+ * @returns {Promise<void>}
+ */
+ push(remote?: string, branch?: string, options?: Options): Promise<void>;
+
+ /**
+ * Pushes the current tag changes to a remote which can be either a URL or named remote. When not
specified uses the
+ * default configured remote spec.
+ *
+ * @param {string} [remote]
+ */
+ pushTags(remote?: string): Promise<string>;
+
+ /**
+ * Executes any command against the git binary.
+ *
+ * @param {string[]|Object} commands
+ */
+ raw(commands: string | string[]): Promise<string>;
+
+ /**
+ * Rebases the current working copy. Options can be supplied either as an array of string parameters
+ * to be sent to the `git rebase` command, or a standard options object.
+ *
+ * @param {Object|String[]} [options]
+ */
+ rebase(options?: Options | string[]): Promise<string>;
+
+ /**
+ * Call any `git remote` function with arguments passed as an array of strings.
+ *
+ * @param {string[]} options
+ */
+ remote(options: string[]): Promise<void | string>;
+
+ /**
+ * Removes an entry from the list of remotes.
+ *
+ * @param {string} remoteName Name of the repository - eg "upstream"
+ * @returns {*}
+ */
+ removeRemote(remote: string): Promise<void>;
+
+ /**
+ * Reset a repo
+ *
+ * @param {string|string[]} [mode=soft] Either an array of arguments supported by the 'git reset'
command, or the string value 'soft' or 'hard' to set the reset mode.
+ */
+ reset(mode?: 'soft' | 'mixed' | 'hard' | 'merge' | 'keep'): Promise<null>;
+
+ reset(commands?: string[]): Promise<void>;
+
+ /**
+ * Revert one or more commits in the local working copy
+ *
+ * @param {string} commit The commit to revert. Can be any hash, offset (eg: `HEAD~2`) or range (eg:
`master~5..master~2`)
+ * @param {Object} [options] Optional options object
+ */
+ revert(commit: String, options?: Options): Promise<void>;
+
+ /**
+ * Wraps `git rev-parse`. Primarily used to convert friendly commit references (ie branch names) to
SHA1 hashes.
+ *
+ * Options should be an array of string options compatible with the `git rev-parse`
+ *
+ * @param {string[]} [options]
+ *
+ * @returns Promise<string>
+ *
+ * @see https://git-scm.com/docs/git-rev-parse
+ */
+ revparse(options?: string[]): Promise<string>;
+
+ /**
+ * Removes the named files from source control.
+ *
+ * @param {string|string[]} files
+ */
+ rm(paths: string | string[]): Promise<void>;
+
+ /**
+ * Removes the named files from source control but keeps them on disk rather than deleting them
entirely. To
+ * completely remove the files, use `rm`.
+ *
+ * @param {string|string[]} files
+ */
+ rmKeepLocal(paths: string | string[]): Promise<void>;
+
+ /**
+ * Show various types of objects, for example the file at a certain commit
+ *
+ * @param {string[]} [options]
+ */
+ show(options?: string[]): Promise<string>;
+
+ /**
+ * Disables/enables the use of the console for printing warnings and errors, by default messages are
not shown in
+ * a production environment.
+ *
+ * @param {boolean} silence
+ * @returns {simplegit.SimpleGit}
+ */
+ silent(silence?: boolean): simplegit.SimpleGit;
+
+ /**
+ * Stash the local repo
+ *
+ * @param {Object|Array} [options]
+ */
+ stash(options?: Options | any[]): Promise<string>;
+
+ /**
+ * List the stash(s) of the local repo
+ *
+ * @param {Object|Array} [options]
+ */
+ stashList(options?: Options | string[]): Promise<resp.ListLogSummary>;
+
+ /**
+ * Show the working tree status.
+ *
+ * @returns {Promise<StatusResult>} Parsed status result.
+ */
+ status(): Promise<StatusResult>;
+
+ /**
+ * Call any `git submodule` function with arguments passed as an array of strings.
+ *
+ * @param {string[]} options
+ */
+ subModule(options: string[]): Promise<string>;
+
+ /**
+ * Add a submodule
+ *
+ * @param {string} repo
+ * @param {string} path
+ */
+ submoduleAdd(repo: string, path: string): Promise<void>;
+
+ /**
+ * Initialize submodules
+ *
+ * @param {string[]} [args]
+ */
+ submoduleInit(options?: string[]): Promise<string>;
+
+ /**
+ * Update submodules
+ *
+ * @param {string[]} [args]
+ */
+ submoduleUpdate(options?: string[]): Promise<string>;
+
+ /**
+ * List all tags. When using git 2.7.0 or above, include an options object with `"--sort":
"property-name"` to
+ * sort the tags by that property instead of using the default semantic versioning sort.
+ *
+ * Note, supplying this option when it is not supported by your Git version will cause the operation
to fail.
+ *
+ * @param {Object} [options]
+ */
+ tag(options?: Options | string[]): Promise<string>;
+
+ /**
+ * Gets a list of tagged versions.
+ *
+ * @param {Options} options
+ * @returns {Promise<TagResult>} Parsed tag list.
+ */
+ tags(options?: Options): Promise<TagResult>;
+
+ /**
+ * Updates repository server info
+ */
+ updateServerInfo(): Promise<string>;
+ }
+
+ type Options = { [key: string]: null | string | any };
+
+ type LogOptions<T = resp.DefaultLogFields> = Options & {
+ format?: T;
+ file?: string;
+ from?: string;
+ multiLine?: boolean;
+ symmetric?: boolean;
+ to?: string;
+ };
+
+ // responses
+ // ---------------------
+ interface BranchSummary extends resp.BranchSummary {}
+
+ interface CommitSummary extends resp.CommitSummary {}
+
+ interface MergeSummary extends resp.MergeSummary {}
+
+ interface PullResult extends resp.PullResult {}
+
+ interface FetchResult extends resp.FetchResult {}
+
+ interface StatusResult extends resp.StatusResult {}
+
+ interface DiffResult extends resp.DiffResult {}
+
+ interface TagResult extends resp.TagResult {}
+
+ type outputHandler = (
+ command: string,
+ stdout: NodeJS.ReadableStream,
+ stderr: NodeJS.ReadableStream
+ ) => void
+}
+
+export = simplegit;
diff --git a/node_modules/simple-git/promise.js b/node_modules/simple-git/promise.js
new file mode 100644
index 00000000..492c8a11
--- /dev/null
+++ b/node_modules/simple-git/promise.js
@@ -0,0 +1,96 @@
+
+if (typeof Promise === 'undefined') {
+ throw new ReferenceError("Promise wrappers must be enabled to use the promise API");
+}
+
+function isAsyncCall (fn) {
+ return /^[^)]+then\s*\)/.test(fn) || /\._run\(/.test(fn);
+}
+
+module.exports = function (baseDir) {
+
+ var Git = require('./src/git');
+ var gitFactory = require('./src');
+ var git;
+
+
+ var chain = Promise.resolve();
+
+ try {
+ git = gitFactory(baseDir);
+ }
+ catch (e) {
+ chain = Promise.reject(e);
+ }
+
+ return Object.keys(Git.prototype).reduce(function (promiseApi, fn) {
+ if (/^_|then/.test(fn)) {
+ return promiseApi;
+ }
+
+ if (isAsyncCall(Git.prototype[fn])) {
+ promiseApi[fn] = git ? asyncWrapper(fn, git) : function () {
+ return chain;
+ };
+ }
+
+ else {
+ promiseApi[fn] = git ? syncWrapper(fn, git, promiseApi) : function () {
+ return promiseApi;
+ };
+ }
+
+ return promiseApi;
+
+ }, {});
+
+ function asyncWrapper (fn, git) {
+ return function () {
+ var args = [].slice.call(arguments);
+
+ if (typeof args[args.length] === 'function') {
+ throw new TypeError(
+ "Promise interface requires that handlers are not supplied inline, " +
+ "trailing function not allowed in call to " + fn);
+ }
+
+ return chain.then(function () {
+ return new Promise(function (resolve, reject) {
+ args.push(function (err, result) {
+ if (err) {
+ return reject(toError(err));
+ }
+
+ resolve(result);
+ });
+
+ git[fn].apply(git, args);
+ });
+ });
+ };
+ }
+
+ function syncWrapper (fn, git, api) {
+ return function () {
+ git[fn].apply(git, arguments);
+
+ return api;
+ };
+ }
+
+};
+
+function toError (error) {
+
+ if (error instanceof Error) {
+ return error;
+ }
+
+ if (typeof error === 'string') {
+ return new Error(error);
+ }
+
+ return Object.create(new Error(error), {
+ git: { value: error },
+ });
+}
diff --git a/node_modules/simple-git/readme.md b/node_modules/simple-git/readme.md
new file mode 100644
index 00000000..ebeb8898
--- /dev/null
+++ b/node_modules/simple-git/readme.md
@@ -0,0 +1,380 @@
+# Simple Git
+[](https://www.npmjs.com/package/simple-git)
[](https://travis-ci.org/steveukx/git-js)
+
+A light weight interface for running git commands in any [node.js](https://nodejs.org) application.
+
+# Installation
+
+Easiest through [npm](https://npmjs.org): `npm install simple-git`
+
+# Dependencies
+
+Requires [git](https://git-scm.com/downloads) to be installed and that it can be called using the command
`git`.
+
+# Usage
+
+Include into your app using:
+
+```js
+const simpleGit = require('simple-git')(workingDirPath);
+```
+
+> where the `workingDirPath` is optional, defaulting to the current directory.
+
+Use `simpleGit` by chaining any of its functions together. Each function accepts an optional final argument
which will
+be called when that step has been completed. When it is called it has two arguments - firstly an error
object (or null
+when no error occurred) and secondly the data generated by that call.
+
+| API | What it does |
+|-----|--------------|
+| `.add([fileA, ...], handlerFn)` | adds one or more files to be under source control |
+| `.addAnnotatedTag(tagName, tagMessage, handlerFn)` | adds an annotated tag to the head of the current
branch |
+| `.addConfig(key, value[, handlerFn])` | add a local configuration property |
+| `.addRemote(name, repo, handlerFn)` | adds a new named remote to be tracked as `name` at the path `repo` |
+| `.addTag(name, handlerFn)` | adds a lightweight tag to the head of the current branch |
+| `.branch([options, ][handlerFn])` | gets a list of all branches, calls `handlerFn` with two arguments, an
error object and [BranchSummary](src/responses/BranchSummary.js) instance. When supplied, the options can be
either an array of arguments supported by the [branch](https://git-scm.com/docs/git-branch) command or a
standard [options](#how-to-specify-options) object. |
+| `.branchLocal([handlerFn])` | gets a list of local branches, calls `handlerFn` with two arguments, an
error object and [BranchSummary](src/responses/BranchSummary.js) instance |
+| `.catFile(options[, handlerFn])` | generate `cat-file` detail, `options` should be an array of strings as
supported arguments to the [cat-file](https://git-scm.com/docs/git-cat-file) command |
+| `.checkIgnore([filepath, ...], handlerFn)` | checks if filepath excluded by .gitignore rules |
+| `.checkIsRepo(handlerFn)` | Determines whether the current working directory is part of a git repository,
the handler will be called with standard error object and a boolean response. |
+| `.checkout(checkoutWhat, handlerFn)` | checks out the supplied tag, revision or branch. `checkoutWhat` can
be one or more strings to be used as parameters appended to the `git checkout` command. |
+| `.checkoutBranch(branchName, startPoint, handlerFn)` | checks out a new branch from the supplied start
point |
+| `.checkoutLatestTag(handlerFn)` | convenience method to pull then checkout the latest tag |
+| `.checkoutLocalBranch(branchName, handlerFn)` | checks out a new local branch |
+| `.clean(mode [, options [, handlerFn]])` | clean the working tree. Mode should be "n" - dry run or "f" -
force |
+| `.clearQueue()` | immediately clears the queue of pending tasks (note: any command currently in progress
will still call its completion callback) |
+| `.clone(repoPath, [localPath, [options]], [handlerFn])` | clone a remote repo at `repoPath` to a local
directory at `localPath` (can be omitted to use the default of a directory with the same name as the repo
name) with an optional array of additional arguments to include between `git clone` and the trailing `repo
local` arguments |
+| `.commit(message, handlerFn)` | commits changes in the current working directory with the supplied message
where the message can be either a single string or array of strings to be passed as separate arguments (the
`git` command line interface converts these to be separated by double line breaks) |
+| `.commit(message, [fileA, ...], options, handlerFn)` | commits changes on the named files with the
supplied message, when supplied, the optional options object can contain any other parameters to pass to the
commit command, setting the value of the property to be a string will add `name=value` to the command string,
setting any other type of value will result in just the key from the object being passed (ie: just `name`),
an example of setting the author is below |
+| `.customBinary(gitPath)` | sets the command to use to reference git, allows for using a git binary not
available on the path environment variable |
+| `.cwd(workingDirectory)` | Sets the current working directory for all commands after this step in the
chain |
+| `.deleteLocalBranch(branchName, handlerFn)` | deletes a local branch |
+| `.diff(options, handlerFn)` | get the diff of the current repo compared to the last commit with a set of
options supplied as a string |
+| `.diff(handlerFn)` | get the diff for all file in the current repo compared to the last commit |
+| `.diffSummary(handlerFn)` | gets a summary of the diff for files in the repo, uses the `git diff --stat`
format to calculate changes. Handler is called with a nullable error object and an instance of the
[DiffSummary](src/responses/DiffSummary.js) |
+| `.diffSummary(options, handlerFn)` | includes options in the call to `diff --stat options` and returns a
[DiffSummary](src/responses/DiffSummary.js) |
+| `.env(name, value)` | Set environment variables to be passed to the spawned child processes, [see usage in
detail below](#environment-variables). |
+| `.exec(handlerFn)` | calls a simple function in the current step |
+| `.fetch([options, ] handlerFn)` | update the local working copy database with changes from the default
remote repo and branch, when supplied the options argument can be a standard [options
object](#how-to-specify-options) either an array of string commands as supported by the [git
fetch](https://git-scm.com/docs/git-fetch). On success, the returned data will be an instance of the
[FetchSummary](src/responses/FetchSummary.js) |
+| `.fetch(remote, branch, handlerFn)` | update the local working copy database with changes from a remote
repo |
+| `.fetch(handlerFn)` | update the local working copy database with changes from the default remote repo and
branch |
+| `.getRemotes([verbose], handlerFn)` | gets a list of the named remotes, when the verbose option is
supplied as true, includes the URLs and purpose of each ref |
+| `.init(bare, handlerFn)` | initialize a repository, optional `bare` parameter makes intialized repository
bare |
+| `.listRemote([args], handlerFn)` | lists remote repositories - there are so many optional arguments in the
underlying `git ls-remote` call, just supply any you want to use as the optional `args` array of strings eg:
`git.listRemote(['--heads', '--tags'], console.log.bind(console))` |
+| `.log([options], handlerFn)` | list commits between `options.from` and `options.to` tags or branch (if not
specified will show all history). Additionally you can provide `options.file`, which is the path to a file in
your repository. Then only this file will be considered. `options.symmetric` allows you to specify whether
you want to use [symmetric revision range](https://git-scm.com/docs/gitrevisions#_dotted_range_notations) (To
be compatible, by default, its value is true). For any other set of options, supply `options` as an array of
strings to be appended to the `git log` command. To use a custom splitter in the log format, set
`options.splitter` to be the string the log should be split on. Set `options.multiLine` to true to include a
multi-line body in the output format. Options can also be supplied as a standard
[options](#how-to-specify-options) object for adding custom properties supported by the [git
log](https://git-scm.com/docs/git-log) command. |
+| `.mergeFromTo(from, to, [[options,] handlerFn])` | merge from one branch to another, when supplied the
options should be an array of additional parameters to pass into the [git
merge](https://git-scm.com/docs/git-merge) command |
+| `.merge(options, handlerFn)` | runs a merge, `options` can be either an array of arguments supported by
the [git merge](https://git-scm.com/docs/git-merge) command or an [options](#how-to-specify-options) object.
Conflicts during the merge result in an error response, the response type whether it was an error or success
will be a [MergeSummary](src/responses/MergeSummary.js) instance. When successful, the MergeSummary has all
detail from a the [PullSummary](src/responses/PullSummary.js) |
+| `.mirror(repoPath, localPath, handlerFn])` | clone and mirror the repo to local |
+| `.mv(from, to, handlerFn])` | rename or move a single file at `from` to `to`. On success the `handlerFn`
will be called with a [MoveSummary](src/responses/MoveSummary.js) |
+| `.mv(from, to, handlerFn])` | move all files in the `from` array to the `to` directory. On success the
`handlerFn` will be called with a [MoveSummary](src/responses/MoveSummary.js) |
+| `.outputHandler(handlerFn)` | attaches a handler that will be called with the name of the command being
run and the `stdout` and `stderr` [readable
streams](https://nodejs.org/api/stream.html#stream_class_stream_readable) created by the [child
process](https://nodejs.org/api/child_process.html#child_process_class_childprocess) running that command |
+| `.pull(handlerFn)` | Pulls all updates from the default tracked repo |
+| `.pull(remote, branch, handlerFn)` | pull all updates from the specified remote branch (eg
'origin'/'master') |
+| `.pull(remote, branch, options, handlerFn)` | Pulls from named remote with any necessary options |
+| `.push(remote, branch[, options] handlerFn)` | pushes to a named remote/branch, supports additional
[options](#how-to-specify-options) from the [git push](https://git-scm.com/docs/git-push) command. |
+| `.pushTags(remote, handlerFn)` | pushes tags to a named remote |
+| `.raw(args[, handlerFn])` | Execute any arbitrary array of commands supported by the underlying git
binary. When the git process returns a non-zero signal on exit and it printed something to `stderr`, the
commmand will be treated as an error, otherwise treated as a success. |
+| `.rebase([options,] handlerFn)` | Rebases the repo, `options` should be supplied as an array of string
parameters supported by the [git rebase](https://git-scm.com/docs/git-rebase) command, or an object of
options (see details below for option formats). |
+| `.removeRemote(name, handlerFn)` | removes the named remote |
+| `.reset([resetMode,] handlerFn)` | resets the repository, the optional first argument can either be an
array of options supported by the `git reset` command or one of the string constants `mixed`, `hard`, or
`soft`, if omitted the reset will be a soft reset to head, handlerFn: (err) |
+| `.revert(commit [, options [, handlerFn]])` | reverts one or more commits in the working copy. The commit
can be any regular commit-ish value (hash, name or offset such as `HEAD~2`) or a range of commits (eg:
`master~5..master~2`). When supplied the [options](#how-to-specify-options) argument contain any options
accepted by [git-revert](https://git-scm.com/docs/git-revert). |
+| `.revparse([options], handlerFn)` | wraps git rev-parse. Primarily used to convert friendly commit
references (ie branch names) to SHA1 hashes. Options should be an array of string options compatible with the
[git rev-parse](https://git-scm.com/docs/git-rev-parse) |
+| `.rm([fileA, ...], handlerFn)` | removes any number of files from source control |
+| `.rmKeepLocal([fileA, ...], handlerFn)` | removes files from source control but leaves them on disk |
+| `.silent(isSilent)` | sets whether the console should be used for logging errors (defaults to `true` when
the `NODE_ENV` contains the string `prod`) |
+| `.stash([options, ][ handlerFn])` | Stash the working directory, optional first argument can be an array
of string arguments or [options](#how-to-specify-options) object to pass to the [git
stash](https://git-scm.com/docs/git-stash) command. |
+| `.stashList([options, ][handlerFn])` | Retrieves the stash list, optional first argument can be an object
specifying `options.splitter` to override the default value of `;;;;`, alternatively options can be a set of
arguments as supported by the `git stash list` command. |
+| `.subModule(args [, handlerFn])` | Run a `git submodule` command with on or more arguments passed in as an
`args` array |
+| `.submoduleAdd(repo, path[, handlerFn])` | adds a new sub module |
+| `.submoduleInit([args, ][handlerFn])` | inits sub modules, args should be an array of string arguments to
pass to the `git submodule init` command |
+| `.submoduleUpdate([args, ][handlerFn])` | updates sub modules, args should be an array of string arguments
to pass to the `git submodule update` command |
+| `.tag(args[], handlerFn)` | Runs any supported [git tag](https://git-scm.com/docs/git-tag) commands with
arguments passed as an array of strings . |
+| `.tags([options, ] handlerFn)` | list all tags, use the optional [options](#how-to-specify-options) object
to set any options allows by the [git tag](https://git-scm.com/docs/git-tag) command. Tags will be sorted by
semantic version number by default, for git versions 2.7 and above, use the `--sort` option to set a custom
sort. |
+| `.show([options], handlerFn)` | Show various types of objects, for example the file content at a certain
commit. `options` is the single value string or array of string commands you want to run |
+| `.status(handlerFn)` | gets the status of the current repo |
+
+# How to Specify Options
+
+For `.pull` or `.commit` options are included as an object, the keys of which will all be merged as trailing
+arguments in the command string. When the value of the property in the options object is a `string`, that
name value
+pair will be included in the command string as `name=value`. For example:
+
+```js
+// results in 'git pull origin master --no-rebase'
+git().pull('origin', 'master', {'--no-rebase': null})
+
+// results in 'git pull origin master --rebase=true'
+git().pull('origin', 'master', {'--rebase': 'true'})
+```
+
+# Release History
+
+Bumped to a new major revision in the 1.x branch, now uses `ChildProcess.spawn` in place of
`ChildProcess.exec` to
+add escaping to the arguments passed to each of the tasks.
+
+# Deprecated APIs
+
+Use of these APIs is deprecated and should be avoided as support for them will be removed in future release:
+
+`.then(func)` In versions 1.72 and below, it was possible to add a regular function call to the queue of
tasks to be
+ run. As this name clashes with the use of Promises, in version 1.73.0 it is renamed to `.exec(fn)` and a
warning will
+ be logged to `stdout` if `.then` is used. From version 2.0 the library will support promises without the
need to wrap
+ or use the alternative require `require('simple-git/promise')`.
+
+`.log([from, to], handlerFn)` list commits between `from` and `to` tags or branch, switch to supplying the
revisions
+as an options object instead.
+
+# Complex Requests
+
+When no suitable wrapper exists in the interface for creating a request, it is possible to run a command
directly
+using `git.raw([...], handler)`. The array of commands are passed directly to the `git` binary:
+
+```js
+const git = require('simple-git');
+const path = '/path/to/repo';
+
+git(path).raw(
+[
+ 'config',
+ '--global',
+ 'advice.pushNonFastForward',
+ 'false'
+], (err, result) => {
+
+ // err is null unless this command failed
+ // result is the raw output of this command
+
+});
+```
+
+# Authentication
+
+The easiest way to supply a username / password to the remote host is to include it in the URL, for example:
+
+```js
+const USER = 'something';
+const PASS = 'somewhere';
+const REPO = 'github.com/username/private-repo';
+
+const git = require('simple-git/promise');
+const remote = `https://${USER}:${PASS}@${REPO}`;
+
+git().silent(true)
+ .clone(remote)
+ .then(() => console.log('finished'))
+ .catch((err) => console.error('failed: ', err));
+
+```
+
+Be sure to enable silent mode to prevent fatal errors from being logged to stdout.
+
+# Environment Variables
+
+Pass one or more environment variables to the child processes spawned by `simple-git` with the `.env` method
which
+supports passing either an object of name=value pairs or setting a single variable at a time:
+
+```js
+const GIT_SSH_COMMAND = "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no";
+
+const git = require('simple-git');
+
+git()
+ .env('GIT_SSH_COMMAND', GIT_SSH_COMMAND)
+ .status((err, status) => { /* */ })
+
+
+const gitP = require('simple-git/promise');
+
+gitP().env({ ...process.env, GIT_SSH_COMMAND })
+ .status()
+ .then(status => { })
+ .catch(err => {});
+
+```
+
+Note - when passing environment variables into the child process, these will replace the standard
`process.env`
+variables, the example above creates a new object based on `process.env` but with the `GIT_SSH_COMMAND`
property
+added.
+
+# TypeScript
+
+To import with TypeScript:
+
+```typescript
+import gitP, { SimpleGit, StatusResult } from 'simple-git/promise';
+
+const git: SimpleGit = gitP();
+const status: StatusResult = await git.status();
+```
+
+# Promise and async compatible
+
+To work with promises (either directly or as part of async/await), load the promise wrappers library:
+
+```js
+const simpleGit = require('simple-git/promise');
+const git = simpleGit();
+
+const status = await git.status();
+```
+
+Exceptions (generally recognised by the git process exiting with a non-zero status, or in some cases
+like `merge` the git process exits with a successful zero code but there are conflicts in the merge)
+should be handled by catching:
+
+```js
+try {
+ const mergeSummary = await git.merge();
+ console.log(`Merged ${ mergeSummary.merges.length } files`);
+}
+catch (err) {
+ // err.message - the string summary of the error
+ // err.stack - some stack trace detail
+ // err.git - where a parser was able to run, this is the parsed content
+
+ console.error(`Merge resulted in ${ err.git.conflicts.length } conflicts`);
+}
+```
+
+# Response Object Revisions
+
+| Class | Version | Change |
+| ListLogLine | v1.110.0 | The default format expression used in `.log` splits ref data out of the `message`
into a property of its own: `{ message: 'Some commit message (some-branch-name)' }` becomes `{ message:
'Some commit message', refs: 'some-branch-name' }` |
+| ListLogLine | v1.110.0 | The commit body content is now included in the default format expression and can
be used to identify the content of merge conflicts eg: `{ body: '# Conflicts:\n# some-file.txt' }` |
+
+# Troubleshooting
+
+### Every command returns ENOENT error message
+
+There are a few potential reasons:
+
+- `git` isn't available as a binary for the user running the main `node` process, custom paths to the binary
can be used
+ with the `.customBinary(...)` api option.
+- the working directory passed in to the main `simple-git` function isn't accessible, check it is read/write
accessible
+ by the user running the `node` process.
+
+### Log response properties are out of order
+
+The properties of `git.log` are fetched using a `;` as a delimiter. If your commit messages use the `;`
character,
+supply a custom `splitter` in the options, for example: `git.log({ splitter: '|||' })`
+
+# Examples
+
+### async await with simple-git/promise:
+
+```js
+async function status (workingDir) {
+ const git = require('simple-git/promise');
+
+ let statusSummary = null;
+ try {
+ statusSummary = await git(workingDir).status();
+ }
+ catch (e) {
+ // handle the error
+ }
+
+ return statusSummary;
+}
+
+// using the async function
+status(__dirname + '/some-repo').then(status => console.log(status));
+```
+
+### Initialise a git repo if necessary
+```js
+const gitP = require('simple-git/promise');
+const git = gitP(__dirname);
+
+git.checkIsRepo()
+ .then(isRepo => !isRepo && initialiseRepo(git))
+ .then(() => git.fetch());
+
+function initialiseRepo (git) {
+ return git.init()
+ .then(() => git.addRemote('origin', 'https://some.git.repo'))
+}
+```
+
+### Update repo and get a list of tags
+```js
+require('simple-git')(__dirname + '/some-repo')
+ .pull()
+ .tags((err, tags) => console.log("Latest available tag: %s", tags.latest));
+
+// update repo and when there are changes, restart the app
+require('simple-git')()
+ .pull((err, update) => {
+ if(update && update.summary.changes) {
+ require('child_process').exec('npm restart');
+ }
+ });
+```
+
+### Starting a new repo
+```js
+require('simple-git')()
+ .init()
+ .add('./*')
+ .commit("first commit!")
+ .addRemote('origin', 'https://github.com/user/repo.git')
+ .push('origin', 'master');
+```
+
+### push with `-u`
+```js
+require('simple-git')()
+ .add('./*')
+ .commit("first commit!")
+ .addRemote('origin', 'some-repo-url')
+ .push(['-u', 'origin', 'master'], () => console.log('done'));
+```
+
+### Piping to the console for long running tasks
+```js
+require('simple-git')()
+ .outputHandler((command, stdout, stderr) => {
+ stdout.pipe(process.stdout);
+ stderr.pipe(process.stderr);
+ })
+ .checkout('https://github.com/user/repo.git');
+```
+
+### Update repo and print messages when there are changes, restart the app
+```js
+require('simple-git')()
+ .exec(() => console.log('Starting pull...'))
+ .pull((err, update) => {
+ if(update && update.summary.changes) {
+ require('child_process').exec('npm restart');
+ }
+ })
+ .exec(() => console.log('pull done.'));
+```
+
+### Get a full commits list, and then only between 0.11.0 and 0.12.0 tags
+```js
+require('simple-git')()
+ .log((err, log) => console.log(log))
+ .log('0.11.0', '0.12.0', (err, log) => console.log(log));
+```
+
+### Set the local configuration for author, then author for an individual commit
+```js
+require('simple-git')()
+ .addConfig('user.name', 'Some One')
+ .addConfig('user.email', 'some one com')
+ .commit('committed as "Some One"', 'file-one')
+ .commit('committed as "Another Person"', 'file-two', { '--author': '"Another Person <another person
com>"' });
+```
+
+### Get remote repositories
+```js
+require('simple-git')()
+ .listRemote(['--get-url'], (err, data) => {
+ if (!err) {
+ console.log('Remote url for repository at ' + __dirname + ':');
+ console.log(data);
+ }
+ });
+```
diff --git a/node_modules/simple-git/src/git.js b/node_modules/simple-git/src/git.js
new file mode 100644
index 00000000..72239e92
--- /dev/null
+++ b/node_modules/simple-git/src/git.js
@@ -0,0 +1,1592 @@
+(function () {
+
+ 'use strict';
+
+ var debug = require('debug')('simple-git');
+ var deferred = require('./util/deferred');
+ var exists = require('./util/exists');
+ var NOOP = function () {};
+ var responses = require('./responses');
+
+ /**
+ * Git handling for node. All public functions can be chained and all `then` handlers are optional.
+ *
+ * @param {string} baseDir base directory for all processes to run
+ *
+ * @param {Object} ChildProcess The ChildProcess module
+ * @param {Function} Buffer The Buffer implementation to use
+ *
+ * @constructor
+ */
+ function Git (baseDir, ChildProcess, Buffer) {
+ this._baseDir = baseDir;
+ this._runCache = [];
+
+ this.ChildProcess = ChildProcess;
+ this.Buffer = Buffer;
+ }
+
+ /**
+ * @type {string} The command to use to reference the git binary
+ */
+ Git.prototype._command = 'git';
+
+ /**
+ * @type {[key: string]: string} An object of key=value pairs to be passed as environment variables to the
+ * spawned child process.
+ */
+ Git.prototype._env = null;
+
+ /**
+ * @type {Function} An optional handler to use when a child process is created
+ */
+ Git.prototype._outputHandler = null;
+
+ /**
+ * @type {boolean} Property showing whether logging will be silenced - defaults to true in a production
environment
+ */
+ Git.prototype._silentLogging = /prod/.test(process.env.NODE_ENV);
+
+ /**
+ * Sets the path to a custom git binary, should either be `git` when there is an installation of git
available on
+ * the system path, or a fully qualified path to the executable.
+ *
+ * @param {string} command
+ * @returns {Git}
+ */
+ Git.prototype.customBinary = function (command) {
+ this._command = command;
+ return this;
+ };
+
+ /**
+ * Sets an environment variable for the spawned child process, either supply both a name and value as
strings or
+ * a single object to entirely replace the current environment variables.
+ *
+ * @param {string|Object} name
+ * @param {string} [value]
+ * @returns {Git}
+ */
+ Git.prototype.env = function (name, value) {
+ if (arguments.length === 1 && typeof name === 'object') {
+ this._env = name;
+ }
+ else {
+ (this._env = this._env || {})[name] = value;
+ }
+
+ return this;
+ };
+
+ /**
+ * Sets the working directory of the subsequent commands.
+ *
+ * @param {string} workingDirectory
+ * @param {Function} [then]
+ * @returns {Git}
+ */
+ Git.prototype.cwd = function (workingDirectory, then) {
+ var git = this;
+ var next = Git.trailingFunctionArgument(arguments);
+
+ return this.exec(function () {
+ git._baseDir = workingDirectory;
+ if (!exists(workingDirectory, exists.FOLDER)) {
+ Git.exception(git, 'Git.cwd: cannot change to non-directory "' + workingDirectory + '"', next);
+ }
+ else {
+ next && next(null, workingDirectory);
+ }
+ });
+ };
+
+ /**
+ * Sets a handler function to be called whenever a new child process is created, the handler function
will be called
+ * with the name of the command being run and the stdout & stderr streams used by the ChildProcess.
+ *
+ * @example
+ * require('simple-git')
+ * .outputHandler(function (command, stdout, stderr) {
+ * stdout.pipe(process.stdout);
+ * })
+ * .checkout('https://github.com/user/repo.git');
+ *
+ * @see https://nodejs.org/api/child_process.html#child_process_class_childprocess
+ * @see https://nodejs.org/api/stream.html#stream_class_stream_readable
+ * @param {Function} outputHandler
+ * @returns {Git}
+ */
+ Git.prototype.outputHandler = function (outputHandler) {
+ this._outputHandler = outputHandler;
+ return this;
+ };
+
+ /**
+ * Initialize a git repo
+ *
+ * @param {Boolean} [bare=false]
+ * @param {Function} [then]
+ */
+ Git.prototype.init = function (bare, then) {
+ var commands = ['init'];
+ var next = Git.trailingFunctionArgument(arguments);
+
+ if (bare === true) {
+ commands.push('--bare');
+ }
+
+ return this._run(commands, function (err) {
+ next && next(err);
+ });
+ };
+
+ /**
+ * Check the status of the local repo
+ *
+ * @param {Function} [then]
+ */
+ Git.prototype.status = function (then) {
+ return this._run(
+ ['status', '--porcelain', '-b', '-u'],
+ Git._responseHandler(then, 'StatusSummary')
+ );
+ };
+
+ /**
+ * List the stash(s) of the local repo
+ *
+ * @param {Object|Array} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.stashList = function (options, then) {
+ var handler = Git.trailingFunctionArgument(arguments);
+ var opt = (handler === then ? options : null) || {};
+
+ var splitter = opt.splitter || requireResponseHandler('ListLogSummary').SPLITTER;
+ var command = ["stash", "list", "--pretty=format:"
+ + requireResponseHandler('ListLogSummary').START_BOUNDARY
+ + "%H %ai %s%d %aN %ae".replace(/\s+/g, splitter)
+ + requireResponseHandler('ListLogSummary').COMMIT_BOUNDARY
+ ];
+
+ if (Array.isArray(opt)) {
+ command = command.concat(opt);
+ }
+
+ return this._run(command,
+ Git._responseHandler(handler, 'ListLogSummary', splitter)
+ );
+ };
+
+ /**
+ * Stash the local repo
+ *
+ * @param {Object|Array} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.stash = function (options, then) {
+ var command = ['stash'];
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+ command.push.apply(command, Git.trailingArrayArgument(arguments));
+
+ return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
+ };
+
+ /**
+ * Clone a git repo
+ *
+ * @param {string} repoPath
+ * @param {string} localPath
+ * @param {String[]} [options] Optional array of options to pass through to the clone command
+ * @param {Function} [then]
+ */
+ Git.prototype.clone = function (repoPath, localPath, options, then) {
+ var next = Git.trailingFunctionArgument(arguments);
+ var command = ['clone'].concat(Git.trailingArrayArgument(arguments));
+
+ for (var i = 0, iMax = arguments.length; i < iMax; i++) {
+ if (typeof arguments[i] === 'string') {
+ command.push(arguments[i]);
+ }
+ }
+
+ return this._run(command, function (err, data) {
+ next && next(err, data);
+ });
+ };
+
+ /**
+ * Mirror a git repo
+ *
+ * @param {string} repoPath
+ * @param {string} localPath
+ * @param {Function} [then]
+ */
+ Git.prototype.mirror = function (repoPath, localPath, then) {
+ return this.clone(repoPath, localPath, ['--mirror'], then);
+ };
+
+ /**
+ * Moves one or more files to a new destination.
+ *
+ * @see https://git-scm.com/docs/git-mv
+ *
+ * @param {string|string[]} from
+ * @param {string} to
+ * @param {Function} [then]
+ */
+ Git.prototype.mv = function (from, to, then) {
+ var handler = Git.trailingFunctionArgument(arguments);
+
+ var command = [].concat(from);
+ command.unshift('mv', '-v');
+ command.push(to);
+
+ this._run(command, Git._responseHandler(handler, 'MoveSummary'))
+ };
+
+ /**
+ * Internally uses pull and tags to get the list of tags then checks out the latest tag.
+ *
+ * @param {Function} [then]
+ */
+ Git.prototype.checkoutLatestTag = function (then) {
+ var git = this;
+ return this.pull(function () {
+ git.tags(function (err, tags) {
+ git.checkout(tags.latest, then);
+ });
+ });
+ };
+
+ /**
+ * Adds one or more files to source control
+ *
+ * @param {string|string[]} files
+ * @param {Function} [then]
+ */
+ Git.prototype.add = function (files, then) {
+ return this._run(['add'].concat(files), function (err, data) {
+ then && then(err);
+ });
+ };
+
+ /**
+ * Commits changes in the current working directory - when specific file paths are supplied, only changes
on those
+ * files will be committed.
+ *
+ * @param {string|string[]} message
+ * @param {string|string[]} [files]
+ * @param {Object} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.commit = function (message, files, options, then) {
+ var handler = Git.trailingFunctionArgument(arguments);
+
+ var command = ['commit'];
+
+ [].concat(message).forEach(function (message) {
+ command.push('-m', message);
+ });
+
+ [].push.apply(command, [].concat(typeof files === "string" || Array.isArray(files) ? files : []));
+
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+
+ return this._run(
+ command,
+ Git._responseHandler(handler, 'CommitSummary')
+ );
+ };
+
+ /**
+ * Gets a function to be used for logging.
+ *
+ * @param {string} level
+ * @param {string} [message]
+ *
+ * @returns {Function}
+ * @private
+ */
+ Git.prototype._getLog = function (level, message) {
+ var log = this._silentLogging ? NOOP : console[level].bind(console);
+ if (arguments.length > 1) {
+ log(message);
+ }
+ return log;
+ };
+
+ /**
+ * Pull the updated contents of the current repo
+ *
+ * @param {string} [remote] When supplied must also include the branch
+ * @param {string} [branch] When supplied must also include the remote
+ * @param {Object} [options] Optionally include set of options to merge into the command
+ * @param {Function} [then]
+ */
+ Git.prototype.pull = function (remote, branch, options, then) {
+ var command = ["pull"];
+ var handler = Git.trailingFunctionArgument(arguments);
+
+ if (typeof remote === 'string' && typeof branch === 'string') {
+ command.push(remote, branch);
+ }
+
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+
+ return this._run(command, Git._responseHandler(handler, 'PullSummary'));
+ };
+
+ /**
+ * Fetch the updated contents of the current repo.
+ *
+ * @example
+ * .fetch('upstream', 'master') // fetches from master on remote named upstream
+ * .fetch(function () {}) // runs fetch against default remote and branch and calls function
+ *
+ * @param {string} [remote]
+ * @param {string} [branch]
+ * @param {Function} [then]
+ */
+ Git.prototype.fetch = function (remote, branch, then) {
+ var command = ["fetch"];
+ var next = Git.trailingFunctionArgument(arguments);
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+
+ if (typeof remote === 'string' && typeof branch === 'string') {
+ command.push(remote, branch);
+ }
+
+ if (Array.isArray(remote)) {
+ command = command.concat(remote);
+ }
+
+ return this._run(
+ command,
+ Git._responseHandler(next, 'FetchSummary'),
+ {
+ concatStdErr: true
+ }
+ );
+ };
+
+ /**
+ * Disables/enables the use of the console for printing warnings and errors, by default messages are not
shown in
+ * a production environment.
+ *
+ * @param {boolean} silence
+ * @returns {Git}
+ */
+ Git.prototype.silent = function (silence) {
+ this._silentLogging = !!silence;
+ return this;
+ };
+
+ /**
+ * List all tags. When using git 2.7.0 or above, include an options object with `"--sort":
"property-name"` to
+ * sort the tags by that property instead of using the default semantic versioning sort.
+ *
+ * Note, supplying this option when it is not supported by your Git version will cause the operation to
fail.
+ *
+ * @param {Object} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.tags = function (options, then) {
+ var next = Git.trailingFunctionArgument(arguments);
+
+ var command = ['-l'];
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+
+ var hasCustomSort = command.some(function (option) {
+ return /^--sort=/.test(option);
+ });
+
+ return this.tag(
+ command,
+ Git._responseHandler(next, 'TagList', [hasCustomSort])
+ );
+ };
+
+ /**
+ * Rebases the current working copy. Options can be supplied either as an array of string parameters
+ * to be sent to the `git rebase` command, or a standard options object.
+ *
+ * @param {Object|String[]} [options]
+ * @param {Function} [then]
+ * @returns {Git}
+ */
+ Git.prototype.rebase = function (options, then) {
+ var command = ['rebase'];
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+ command.push.apply(command, Git.trailingArrayArgument(arguments));
+
+
+ return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
+ };
+
+ /**
+ * Reset a repo
+ *
+ * @param {string|string[]} [mode=soft] Either an array of arguments supported by the 'git reset'
command, or the
+ * string value 'soft' or 'hard' to set the reset mode.
+ * @param {Function} [then]
+ */
+ Git.prototype.reset = function (mode, then) {
+ var command = ['reset'];
+ var next = Git.trailingFunctionArgument(arguments);
+ if (next === mode || typeof mode === 'string' || !mode) {
+ var modeStr = ['mixed', 'soft', 'hard'].includes(mode) ? mode : 'soft';
+ command.push('--' + modeStr);
+ }
+ else if (Array.isArray(mode)) {
+ command.push.apply(command, mode);
+ }
+
+ return this._run(command, function (err) {
+ next && next(err || null);
+ });
+ };
+
+ /**
+ * Revert one or more commits in the local working copy
+ *
+ * @param {string} commit The commit to revert. Can be any hash, offset (eg: `HEAD~2`) or range (eg:
`master~5..master~2`)
+ * @param {Object} [options] Optional options object
+ * @param {Function} [then]
+ */
+ Git.prototype.revert = function (commit, options, then) {
+ var next = Git.trailingFunctionArgument(arguments);
+ var command = ['revert'];
+
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+
+ if (typeof commit !== 'string') {
+ return this.exec(function () {
+ next && next(new TypeError("Commit must be a string"));
+ });
+ }
+
+ command.push(commit);
+ return this._run(command, function (err) {
+ next && next(err || null);
+ });
+ };
+
+ /**
+ * Add a lightweight tag to the head of the current branch
+ *
+ * @param {string} name
+ * @param {Function} [then]
+ */
+ Git.prototype.addTag = function (name, then) {
+ if (typeof name !== "string") {
+ return this.exec(function () {
+ then && then(new TypeError("Git.addTag requires a tag name"));
+ });
+ }
+
+ var command = [name];
+ return then ? this.tag(command, then) : this.tag(command);
+ };
+
+ /**
+ * Add an annotated tag to the head of the current branch
+ *
+ * @param {string} tagName
+ * @param {string} tagMessage
+ * @param {Function} [then]
+ */
+ Git.prototype.addAnnotatedTag = function (tagName, tagMessage, then) {
+ return this.tag(['-a', '-m', tagMessage, tagName], function (err) {
+ then && then(err);
+ });
+ };
+
+ /**
+ * Check out a tag or revision, any number of additional arguments can be passed to the `git checkout`
command
+ * by supplying either a string or array of strings as the `what` parameter.
+ *
+ * @param {string|string[]} what One or more commands to pass to `git checkout`
+ * @param {Function} [then]
+ */
+ Git.prototype.checkout = function (what, then) {
+ var command = ['checkout'];
+ command = command.concat(what);
+
+ return this._run(command, function (err, data) {
+ then && then(err, !err && this._parseCheckout(data));
+ });
+ };
+
+ /**
+ * Check out a remote branch
+ *
+ * @param {string} branchName name of branch
+ * @param {string} startPoint (e.g origin/development)
+ * @param {Function} [then]
+ */
+ Git.prototype.checkoutBranch = function (branchName, startPoint, then) {
+ return this.checkout(['-b', branchName, startPoint], then);
+ };
+
+ /**
+ * Check out a local branch
+ *
+ * @param {string} branchName of branch
+ * @param {Function} [then]
+ */
+ Git.prototype.checkoutLocalBranch = function (branchName, then) {
+ return this.checkout(['-b', branchName], then);
+ };
+
+ /**
+ * Delete a local branch
+ *
+ * @param {string} branchName name of branch
+ * @param {Function} [then]
+ */
+ Git.prototype.deleteLocalBranch = function (branchName, then) {
+ return this.branch(['-d', branchName], then);
+ };
+
+ /**
+ * List all branches
+ *
+ * @param {Object | string[]} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.branch = function (options, then) {
+ var isDelete, responseHandler;
+ var next = Git.trailingFunctionArgument(arguments);
+ var command = ['branch'];
+
+ command.push.apply(command, Git.trailingArrayArgument(arguments));
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+
+ if (!arguments.length || next === options) {
+ command.push('-a');
+ }
+
+ isDelete = ['-d', '-D', '--delete'].reduce(function (isDelete, flag) {
+ return isDelete || command.indexOf(flag) > 0;
+ }, false);
+
+ if (command.indexOf('-v') < 0) {
+ command.splice(1, 0, '-v');
+ }
+
+ responseHandler = isDelete
+ ? Git._responseHandler(next, 'BranchDeleteSummary', false)
+ : Git._responseHandler(next, 'BranchSummary');
+
+ return this._run(command, responseHandler);
+ };
+
+ /**
+ * Return list of local branches
+ *
+ * @param {Function} [then]
+ */
+ Git.prototype.branchLocal = function (then) {
+ return this.branch(['-v'], then);
+ };
+
+ /**
+ * Add config to local git instance
+ *
+ * @param {string} key configuration key (e.g user.name)
+ * @param {string} value for the given key (e.g your name)
+ * @param {Function} [then]
+ */
+ Git.prototype.addConfig = function (key, value, then) {
+ return this._run(['config', '--local', key, value], function (err, data) {
+ then && then(err, !err && data);
+ });
+ };
+
+ /**
+ * Executes any command against the git binary.
+ *
+ * @param {string[]|Object} commands
+ * @param {Function} [then]
+ *
+ * @returns {Git}
+ */
+ Git.prototype.raw = function (commands, then) {
+ var command = [];
+ if (Array.isArray(commands)) {
+ command = commands.slice(0);
+ }
+ else {
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+ }
+
+ var next = Git.trailingFunctionArgument(arguments);
+
+ if (!command.length) {
+ return this.exec(function () {
+ next && next(new Error('Raw: must supply one or more command to execute'), null);
+ });
+ }
+
+ return this._run(command, function (err, data) {
+ next && next(err, !err && data || null);
+ });
+ };
+
+ /**
+ * Add a submodule
+ *
+ * @param {string} repo
+ * @param {string} path
+ * @param {Function} [then]
+ */
+ Git.prototype.submoduleAdd = function (repo, path, then) {
+ return this._run(['submodule', 'add', repo, path], function (err) {
+ then && then(err);
+ });
+ };
+
+ /**
+ * Update submodules
+ *
+ * @param {string[]} [args]
+ * @param {Function} [then]
+ */
+ Git.prototype.submoduleUpdate = function (args, then) {
+ if (typeof args === 'string') {
+ this._getLog('warn', 'Git#submoduleUpdate: args should be supplied as an array of individual
arguments');
+ }
+
+ var next = Git.trailingFunctionArgument(arguments);
+ var command = (args !== next) ? args : [];
+
+ return this.subModule(['update'].concat(command), function (err, args) {
+ next && next(err, args);
+ });
+ };
+
+ /**
+ * Initialize submodules
+ *
+ * @param {string[]} [args]
+ * @param {Function} [then]
+ */
+ Git.prototype.submoduleInit = function (args, then) {
+ if (typeof args === 'string') {
+ this._getLog('warn', 'Git#submoduleInit: args should be supplied as an array of individual
arguments');
+ }
+
+ var next = Git.trailingFunctionArgument(arguments);
+ var command = (args !== next) ? args : [];
+
+ return this.subModule(['init'].concat(command), function (err, args) {
+ next && next(err, args);
+ });
+ };
+
+ /**
+ * Call any `git submodule` function with arguments passed as an array of strings.
+ *
+ * @param {string[]} options
+ * @param {Function} [then]
+ */
+ Git.prototype.subModule = function (options, then) {
+ if (!Array.isArray(options)) {
+ return this.exec(function () {
+ then && then(new TypeError("Git.subModule requires an array of arguments"));
+ });
+ }
+
+ if (options[0] !== 'submodule') {
+ options.unshift('submodule');
+ }
+
+ return this._run(options, function (err, data) {
+ then && then(err || null, err ? null : data);
+ });
+ };
+
+ /**
+ * List remote
+ *
+ * @param {string[]} [args]
+ * @param {Function} [then]
+ */
+ Git.prototype.listRemote = function (args, then) {
+ var next = Git.trailingFunctionArgument(arguments);
+ var data = next === args || args === undefined ? [] : args;
+
+ if (typeof data === 'string') {
+ this._getLog('warn', 'Git#listRemote: args should be supplied as an array of individual arguments');
+ }
+
+ return this._run(['ls-remote'].concat(data), function (err, data) {
+ next && next(err, data);
+ });
+ };
+
+ /**
+ * Adds a remote to the list of remotes.
+ *
+ * @param {string} remoteName Name of the repository - eg "upstream"
+ * @param {string} remoteRepo Fully qualified SSH or HTTP(S) path to the remote repo
+ * @param {Function} [then]
+ * @returns {*}
+ */
+ Git.prototype.addRemote = function (remoteName, remoteRepo, then) {
+ return this._run(['remote', 'add', remoteName, remoteRepo], function (err) {
+ then && then(err);
+ });
+ };
+
+ /**
+ * Removes an entry from the list of remotes.
+ *
+ * @param {string} remoteName Name of the repository - eg "upstream"
+ * @param {Function} [then]
+ * @returns {*}
+ */
+ Git.prototype.removeRemote = function (remoteName, then) {
+ return this._run(['remote', 'remove', remoteName], function (err) {
+ then && then(err);
+ });
+ };
+
+ /**
+ * Gets the currently available remotes, setting the optional verbose argument to true includes additional
+ * detail on the remotes themselves.
+ *
+ * @param {boolean} [verbose=false]
+ * @param {Function} [then]
+ */
+ Git.prototype.getRemotes = function (verbose, then) {
+ var next = Git.trailingFunctionArgument(arguments);
+ var args = verbose === true ? ['-v'] : [];
+
+ return this.remote(args, function (err, data) {
+ next && next(err, !err && function () {
+ return data.trim().split('\n').filter(Boolean).reduce(function (remotes, remote) {
+ var detail = remote.trim().split(/\s+/);
+ var name = detail.shift();
+
+ if (!remotes[name]) {
+ remotes[name] = remotes[remotes.length] = {
+ name: name,
+ refs: {}
+ };
+ }
+
+ if (detail.length) {
+ remotes[name].refs[detail.pop().replace(/[^a-z]/g, '')] = detail.pop();
+ }
+
+ return remotes;
+ }, []).slice(0);
+ }());
+ });
+ };
+
+ /**
+ * Call any `git remote` function with arguments passed as an array of strings.
+ *
+ * @param {string[]} options
+ * @param {Function} [then]
+ */
+ Git.prototype.remote = function (options, then) {
+ if (!Array.isArray(options)) {
+ return this.exec(function () {
+ then && then(new TypeError("Git.remote requires an array of arguments"));
+ });
+ }
+
+ if (options[0] !== 'remote') {
+ options.unshift('remote');
+ }
+
+ return this._run(options, function (err, data) {
+ then && then(err || null, err ? null : data);
+ });
+ };
+
+ /**
+ * Merges from one branch to another, equivalent to running `git merge ${from} $[to}`, the `options`
argument can
+ * either be an array of additional parameters to pass to the command or null / omitted to be ignored.
+ *
+ * @param {string} from
+ * @param {string} to
+ * @param {string[]} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.mergeFromTo = function (from, to, options, then) {
+ var commands = [
+ from,
+ to
+ ];
+ var callback = Git.trailingFunctionArgument(arguments);
+
+ if (Array.isArray(options)) {
+ commands = commands.concat(options);
+ }
+
+ return this.merge(commands, callback);
+ };
+
+ /**
+ * Runs a merge, `options` can be either an array of arguments
+ * supported by the [`git merge`](https://git-scm.com/docs/git-merge)
+ * or an options object.
+ *
+ * Conflicts during the merge result in an error response,
+ * the response type whether it was an error or success will be a MergeSummary instance.
+ * When successful, the MergeSummary has all detail from a the PullSummary
+ *
+ * @param {Object | string[]} [options]
+ * @param {Function} [then]
+ * @returns {*}
+ *
+ * @see ./responses/MergeSummary.js
+ * @see ./responses/PullSummary.js
+ */
+ Git.prototype.merge = function (options, then) {
+ var self = this;
+ var userHandler = Git.trailingFunctionArgument(arguments) || NOOP;
+ var mergeHandler = function (err, mergeSummary) {
+ if (!err && mergeSummary.failed) {
+ return Git.fail(self, mergeSummary, userHandler);
+ }
+
+ userHandler(err, mergeSummary);
+ };
+
+ var command = [];
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+ command.push.apply(command, Git.trailingArrayArgument(arguments));
+
+ if (command[0] !== 'merge') {
+ command.unshift('merge');
+ }
+
+ if (command.length === 1) {
+ return this.exec(function () {
+ then && then(new TypeError("Git.merge requires at least one option"));
+ });
+ }
+
+ return this._run(command, Git._responseHandler(mergeHandler, 'MergeSummary'), {
+ concatStdErr: true
+ });
+ };
+
+ /**
+ * Call any `git tag` function with arguments passed as an array of strings.
+ *
+ * @param {string[]} options
+ * @param {Function} [then]
+ */
+ Git.prototype.tag = function (options, then) {
+ var command = [];
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+ command.push.apply(command, Git.trailingArrayArgument(arguments));
+
+ if (command[0] !== 'tag') {
+ command.unshift('tag');
+ }
+
+ return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
+ };
+
+ /**
+ * Updates repository server info
+ *
+ * @param {Function} [then]
+ */
+ Git.prototype.updateServerInfo = function (then) {
+ return this._run(["update-server-info"], function (err, data) {
+ then && then(err, !err && data);
+ });
+ };
+
+ /**
+ * Pushes the current committed changes to a remote, optionally specify the names of the remote and
branch to use
+ * when pushing. Supply multiple options as an array of strings in the first argument - see examples
below.
+ *
+ * @param {string|string[]} [remote]
+ * @param {string} [branch]
+ * @param {Function} [then]
+ */
+ Git.prototype.push = function (remote, branch, then) {
+ var command = [];
+ var handler = Git.trailingFunctionArgument(arguments);
+
+ if (typeof remote === 'string' && typeof branch === 'string') {
+ command.push(remote, branch);
+ }
+
+ if (Array.isArray(remote)) {
+ command = command.concat(remote);
+ }
+
+ Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
+
+ if (command[0] !== 'push') {
+ command.unshift('push');
+ }
+
+ return this._run(command, function (err, data) {
+ handler && handler(err, !err && data);
+ });
+ };
+
+ /**
+ * Pushes the current tag changes to a remote which can be either a URL or named remote. When not
specified uses the
+ * default configured remote spec.
+ *
+ * @param {string} [remote]
+ * @param {Function} [then]
+ */
+ Git.prototype.pushTags = function (remote, then) {
+ var command = ['push'];
+ if (typeof remote === "string") {
+ command.push(remote);
+ }
+ command.push('--tags');
+
+ then = typeof arguments[arguments.length - 1] === "function" ? arguments[arguments.length - 1] : null;
+
+ return this._run(command, function (err, data) {
+ then && then(err, !err && data);
+ });
+ };
+
+ /**
+ * Removes the named files from source control.
+ *
+ * @param {string|string[]} files
+ * @param {Function} [then]
+ */
+ Git.prototype.rm = function (files, then) {
+ return this._rm(files, '-f', then);
+ };
+
+ /**
+ * Removes the named files from source control but keeps them on disk rather than deleting them entirely.
To
+ * completely remove the files, use `rm`.
+ *
+ * @param {string|string[]} files
+ * @param {Function} [then]
+ */
+ Git.prototype.rmKeepLocal = function (files, then) {
+ return this._rm(files, '--cached', then);
+ };
+
+ /**
+ * Returns a list of objects in a tree based on commit hash. Passing in an object hash returns the
object's content,
+ * size, and type.
+ *
+ * Passing "-p" will instruct cat-file to determine the object type, and display its formatted contents.
+ *
+ * @param {string[]} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.catFile = function (options, then) {
+ return this._catFile('utf-8', arguments);
+ };
+
+ /**
+ * Equivalent to `catFile` but will return the native `Buffer` of content from the git command's stdout.
+ *
+ * @param {string[]} options
+ * @param then
+ */
+ Git.prototype.binaryCatFile = function (options, then) {
+ return this._catFile('buffer', arguments);
+ };
+
+ Git.prototype._catFile = function (format, args) {
+ var handler = Git.trailingFunctionArgument(args);
+ var command = ['cat-file'];
+ var options = args[0];
+
+ if (typeof options === 'string') {
+ throw new TypeError('Git#catFile: options must be supplied as an array of strings');
+ }
+ else if (Array.isArray(options)) {
+ command.push.apply(command, options);
+ }
+
+ return this._run(command, function (err, data) {
+ handler && handler(err, data);
+ }, {
+ format: format
+ });
+ };
+
+ /**
+ * Return repository changes.
+ *
+ * @param {string[]} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.diff = function (options, then) {
+ var command = ['diff'];
+
+ if (typeof options === 'string') {
+ command[0] += ' ' + options;
+ this._getLog('warn',
+ 'Git#diff: supplying options as a single string is now deprecated, switch to an array of
strings');
+ }
+ else if (Array.isArray(options)) {
+ command.push.apply(command, options);
+ }
+
+ if (typeof arguments[arguments.length - 1] === 'function') {
+ then = arguments[arguments.length - 1];
+ }
+
+ return this._run(command, function (err, data) {
+ then && then(err, data);
+ });
+ };
+
+ Git.prototype.diffSummary = function (options, then) {
+ var next = Git.trailingFunctionArgument(arguments);
+ var command = ['--stat=4096'];
+
+ if (options && options !== next) {
+ command.push.apply(command, [].concat(options));
+ }
+
+ return this.diff(command, Git._responseHandler(next, 'DiffSummary'));
+ };
+
+ /**
+ * Wraps `git rev-parse`. Primarily used to convert friendly commit references (ie branch names) to SHA1
hashes.
+ *
+ * Options should be an array of string options compatible with the `git rev-parse`
+ *
+ * @param {string|string[]} [options]
+ * @param {Function} [then]
+ *
+ * @see https://git-scm.com/docs/git-rev-parse
+ */
+ Git.prototype.revparse = function (options, then) {
+ var command = ['rev-parse'];
+
+ if (typeof options === 'string') {
+ command = command + ' ' + options;
+ this._getLog('warn',
+ 'Git#revparse: supplying options as a single string is now deprecated, switch to an array of
strings');
+ }
+ else if (Array.isArray(options)) {
+ command.push.apply(command, options);
+ }
+
+ if (typeof arguments[arguments.length - 1] === 'function') {
+ then = arguments[arguments.length - 1];
+ }
+
+ return this._run(command, function (err, data) {
+ then && then(err, err ? null : String(data).trim());
+ });
+ };
+
+ /**
+ * Show various types of objects, for example the file at a certain commit
+ *
+ * @param {string[]} [options]
+ * @param {Function} [then]
+ */
+ Git.prototype.show = function (options, then) {
+ var args = [].slice.call(arguments, 0);
+ var handler = typeof args[args.length - 1] === "function" ? args.pop() : null;
+ var command = ['show'];
+ if (typeof options === 'string') {
+ command = command + ' ' + options;
+ this._getLog('warn',
+ 'Git#show: supplying options as a single string is now deprecated, switch to an array of
strings');
+ }
+ else if (Array.isArray(options)) {
+ command.push.apply(command, options);
+ }
+
+ return this._run(command, function (err, data) {
+ handler && handler(err, !err && data);
+ });
+ };
+
+ /**
+ * @param {string} mode Required parameter "n" or "f"
+ * @param {string[]} options
+ * @param {Function} [then]
+ */
+ Git.prototype.clean = function (mode, options, then) {
+ var handler = Git.trailingFunctionArgument(arguments);
+
+ if (typeof mode !== 'string' || !/[nf]/.test(mode)) {
+ return this.exec(function () {
+ handler && handler(new TypeError('Git clean mode parameter ("n" or "f") is required'));
+ });
+ }
+
+ if (/[^dfinqxX]/.test(mode)) {
+ return this.exec(function () {
+ handler && handler(new TypeError('Git clean unknown option found in ' + JSON.stringify(mode)));
+ });
+ }
+
+ var command = ['clean', '-' + mode];
+ if (Array.isArray(options)) {
+ command = command.concat(options);
+ }
+
+ if (command.some(interactiveMode)) {
+ return this.exec(function () {
+ handler && handler(new TypeError('Git clean interactive mode is not supported'));
+ });
+ }
+
+ return this._run(command, function (err, data) {
+ handler && handler(err, !err && data);
+ });
+
+ function interactiveMode (option) {
+ if (/^-[^\-]/.test(option)) {
+ return option.indexOf('i') > 0;
+ }
+
+ return option === '--interactive';
+ }
+ };
+
+ /**
+ * Call a simple function at the next step in the chain.
+ * @param {Function} [then]
+ */
+ Git.prototype.exec = function (then) {
+ this._run([], function () {
+ typeof then === 'function' && then();
+ });
+ return this;
+ };
+
+ /**
+ * Deprecated means of adding a regular function call at the next step in the chain. Use the replacement
+ * Git#exec, the Git#then method will be removed in version 2.x
+ *
+ * @see exec
+ * @deprecated
+ */
+ Git.prototype.then = function (then) {
+ this._getLog(
+ 'error', `
+Git#then is deprecated after version 1.72 and will be removed in version 2.x
+To use promises switch to importing 'simple-git/promise'.`);
+
+ return this.exec(then);
+ };
+
+ /**
+ * Show commit logs from `HEAD` to the first commit.
+ * If provided between `options.from` and `options.to` tags or branch.
+ *
+ * Additionally you can provide options.file, which is the path to a file in your repository. Then only
this file will be considered.
+ *
+ * To use a custom splitter in the log format, set `options.splitter` to be the string the log should be
split on.
+ *
+ * Options can also be supplied as a standard options object for adding custom properties supported by
the git log command.
+ * For any other set of options, supply options as an array of strings to be appended to the git log
command.
+ *
+ * @param {Object|string[]} [options]
+ * @param {string} [options.from] The first commit to include
+ * @param {string} [options.to] The most recent commit to include
+ * @param {string} [options.file] A single file to include in the result
+ * @param {boolean} [options.multiLine] Optionally include multi-line commit messages
+ *
+ * @param {Function} [then]
+ */
+ Git.prototype.log = function (options, then) {
+ var handler = Git.trailingFunctionArgument(arguments);
+ var opt = (handler === then ? options : null) || {};
+
+ var splitter = opt.splitter || requireResponseHandler('ListLogSummary').SPLITTER;
+ var format = opt.format || {
+ hash: '%H',
+ date: '%ai',
+ message: '%s',
+ refs: '%D',
+ body: opt.multiLine ? '%B' : '%b',
+ author_name: '%aN',
+ author_email: '%ae'
+ };
+ var rangeOperator = (opt.symmetric !== false) ? '...' : '..';
+
+ var fields = Object.keys(format);
+ var formatstr = fields.map(function (k) {
+ return format[k];
+ }).join(splitter);
+ var suffix = [];
+ var command = ["log", "--pretty=format:"
+ + requireResponseHandler('ListLogSummary').START_BOUNDARY
+ + formatstr
+ + requireResponseHandler('ListLogSummary').COMMIT_BOUNDARY
+ ];
+
+ if (Array.isArray(opt)) {
+ command = command.concat(opt);
+ opt = {};
+ }
+ else if (typeof arguments[0] === "string" || typeof arguments[1] === "string") {
+ this._getLog('warn',
+ 'Git#log: supplying to or from as strings is now deprecated, switch to an options configuration
object');
+ opt = {
+ from: arguments[0],
+ to: arguments[1]
+ };
+ }
+
+ if (opt.n || opt['max-count']) {
+ command.push("--max-count=" + (opt.n || opt['max-count']));
+ }
+
+ if (opt.from && opt.to) {
+ command.push(opt.from + rangeOperator + opt.to);
+ }
+
+ if (opt.file) {
+ suffix.push("--follow", options.file);
+ }
+
+ 'splitter n max-count file from to --pretty format symmetric multiLine'.split(' ').forEach(function
(key) {
+ delete opt[key];
+ });
+
+ Git._appendOptions(command, opt);
+
+ return this._run(
+ command.concat(suffix),
+ Git._responseHandler(handler, 'ListLogSummary', [splitter, fields])
+ );
+ };
+
+ /**
+ * Clears the queue of pending commands and returns the wrapper instance for chaining.
+ *
+ * @returns {Git}
+ */
+ Git.prototype.clearQueue = function () {
+ this._runCache.length = 0;
+ return this;
+ };
+
+ /**
+ * Check if a pathname or pathnames are excluded by .gitignore
+ *
+ * @param {string|string[]} pathnames
+ * @param {Function} [then]
+ */
+ Git.prototype.checkIgnore = function (pathnames, then) {
+ var handler = Git.trailingFunctionArgument(arguments);
+ var command = ["check-ignore"];
+
+ if (handler !== pathnames) {
+ command = command.concat(pathnames);
+ }
+
+ return this._run(command, function (err, data) {
+ handler && handler(err, !err && this._parseCheckIgnore(data));
+ });
+ };
+
+ /**
+ * Validates that the current repo is a Git repo.
+ *
+ * @param {Function} [then]
+ */
+ Git.prototype.checkIsRepo = function (then) {
+ function onError (exitCode, stdErr, done, fail) {
+ if (exitCode === 128 && /(Not a git repository|Kein Git-Repository)/i.test(stdErr)) {
+ return done(false);
+ }
+
+ fail(stdErr);
+ }
+
+ function handler (err, isRepo) {
+ then && then(err, String(isRepo).trim() === 'true');
+ }
+
+ return this._run(['rev-parse', '--is-inside-work-tree'], handler, {onError: onError});
+ };
+
+ Git.prototype._rm = function (_files, options, then) {
+ var files = [].concat(_files);
+ var args = ['rm', options];
+ args.push.apply(args, files);
+
+ return this._run(args, function (err) {
+ then && then(err);
+ });
+ };
+
+ Git.prototype._parseCheckout = function (checkout) {
+ // TODO
+ };
+
+ /**
+ * Parser for the `check-ignore` command - returns each
+ * @param {string} [files]
+ * @returns {string[]}
+ */
+ Git.prototype._parseCheckIgnore = function (files) {
+ return files.split(/\n/g).filter(Boolean).map(function (file) {
+ return file.trim()
+ });
+ };
+
+ /**
+ * Schedules the supplied command to be run, the command should not include the name of the git binary
and should
+ * be an array of strings passed as the arguments to the git binary.
+ *
+ * @param {string[]} command
+ * @param {Function} then
+ * @param {Object} [opt]
+ * @param {boolean} [opt.concatStdErr=false] Optionally concatenate stderr output into the stdout
+ * @param {boolean} [opt.format="utf-8"] The format to use when reading the content of stdout
+ * @param {Function} [opt.onError] Optional error handler for this command - can be used to allow
non-clean exits
+ * without killing the remaining stack of commands
+ * @param {number} [opt.onError.exitCode]
+ * @param {string} [opt.onError.stdErr]
+ *
+ * @returns {Git}
+ */
+ Git.prototype._run = function (command, then, opt) {
+ if (typeof command === "string") {
+ command = command.split(" ");
+ }
+ this._runCache.push([command, then, opt || {}]);
+ this._schedule();
+
+ return this;
+ };
+
+ Git.prototype._schedule = function () {
+ if (!this._childProcess && this._runCache.length) {
+ var git = this;
+ var Buffer = git.Buffer;
+ var task = git._runCache.shift();
+
+ var command = task[0];
+ var then = task[1];
+ var options = task[2];
+
+ debug(command);
+
+ var result = deferred();
+
+ var attempted = false;
+ var attemptClose = function attemptClose (e) {
+
+ // closing when there is content, terminate immediately
+ if (attempted || stdErr.length || stdOut.length) {
+ result.resolve(e);
+ attempted = true;
+ }
+
+ // first attempt at closing but no content yet, wait briefly for the close/exit that may follow
+ if (!attempted) {
+ attempted = true;
+ setTimeout(attemptClose.bind(this, e), 50);
+ }
+
+ };
+
+ var stdOut = [];
+ var stdErr = [];
+ var spawned = git.ChildProcess.spawn(git._command, command.slice(0), {
+ cwd: git._baseDir,
+ env: git._env,
+ windowsHide: true
+ });
+
+ spawned.stdout.on('data', function (buffer) {
+ stdOut.push(buffer);
+ });
+
+ spawned.stderr.on('data', function (buffer) {
+ stdErr.push(buffer);
+ });
+
+ spawned.on('error', function (err) {
+ stdErr.push(Buffer.from(err.stack, 'ascii'));
+ });
+
+ spawned.on('close', attemptClose);
+ spawned.on('exit', attemptClose);
+
+ result.promise.then(function (exitCode) {
+ function done (output) {
+ then.call(git, null, output);
+ }
+
+ function fail (error) {
+ Git.fail(git, error, then);
+ }
+
+ delete git._childProcess;
+
+ if (exitCode && stdErr.length && options.onError) {
+ options.onError(exitCode, Buffer.concat(stdErr).toString('utf-8'), done, fail);
+ }
+ else if (exitCode && stdErr.length) {
+ fail(Buffer.concat(stdErr).toString('utf-8'));
+ }
+ else {
+ if (options.concatStdErr) {
+ [].push.apply(stdOut, stdErr);
+ }
+
+ var stdOutput = Buffer.concat(stdOut);
+ if (options.format !== 'buffer') {
+ stdOutput = stdOutput.toString(options.format || 'utf-8');
+ }
+
+ done(stdOutput);
+ }
+
+ process.nextTick(git._schedule.bind(git));
+ });
+
+ git._childProcess = spawned;
+
+ if (git._outputHandler) {
+ git._outputHandler(command[0], git._childProcess.stdout, git._childProcess.stderr);
+ }
+ }
+ };
+
+ /**
+ * Handles an exception in the processing of a command.
+ */
+ Git.fail = function (git, error, handler) {
+ git._getLog('error', error);
+ git._runCache.length = 0;
+ if (typeof handler === 'function') {
+ handler.call(git, error, null);
+ }
+ };
+
+ /**
+ * Given any number of arguments, returns the last argument if it is a function, otherwise returns null.
+ * @returns {Function|null}
+ */
+ Git.trailingFunctionArgument = function (args) {
+ var trailing = args[args.length - 1];
+ return (typeof trailing === "function") ? trailing : null;
+ };
+
+ /**
+ * Given any number of arguments, returns the trailing options argument, ignoring a trailing function
argument
+ * if there is one. When not found, the return value is null.
+ * @returns {Object|null}
+ */
+ Git.trailingOptionsArgument = function (args) {
+ var options = args[(args.length - (Git.trailingFunctionArgument(args) ? 2 : 1))];
+ return Object.prototype.toString.call(options) === '[object Object]' ? options : null;
+ };
+
+ /**
+ * Given any number of arguments, returns the trailing options array argument, ignoring a trailing
function argument
+ * if there is one. When not found, the return value is an empty array.
+ * @returns {Array}
+ */
+ Git.trailingArrayArgument = function (args) {
+ var options = args[(args.length - (Git.trailingFunctionArgument(args) ? 2 : 1))];
+ return Object.prototype.toString.call(options) === '[object Array]' ? options : [];
+ };
+
+ /**
+ * Mutates the supplied command array by merging in properties in the options object. When the
+ * value of the item in the options object is a string it will be concatenated to the key as
+ * a single `name=value` item, otherwise just the name will be used.
+ *
+ * @param {string[]} command
+ * @param {Object} options
+ * @private
+ */
+ Git._appendOptions = function (command, options) {
+ if (options === null) {
+ return;
+ }
+
+ Object.keys(options).forEach(function (key) {
+ var value = options[key];
+ if (typeof value === 'string') {
+ command.push(key + '=' + value);
+ }
+ else {
+ command.push(key);
+ }
+ });
+ };
+
+ /**
+ * Given the type of response and the callback to receive the parsed response,
+ * uses the correct parser and calls back the callback.
+ *
+ * @param {Function} callback
+ * @param {string} [type]
+ * @param {Object[]} [args]
+ *
+ * @private
+ */
+ Git._responseHandler = function (callback, type, args) {
+ return function (error, data) {
+ if (typeof callback !== 'function') {
+ return;
+ }
+
+ if (error) {
+ return callback(error, null);
+ }
+
+ if (!type) {
+ return callback(null, data);
+ }
+
+ var handler = requireResponseHandler(type);
+ var result = handler.parse.apply(handler, [data].concat(args === undefined ? [] : args));
+
+ callback(null, result);
+ };
+
+ };
+
+ /**
+ * Marks the git instance as having had a fatal exception by clearing the pending queue of tasks and
+ * logging to the console.
+ *
+ * @param git
+ * @param error
+ * @param callback
+ */
+ Git.exception = function (git, error, callback) {
+ git._runCache.length = 0;
+ if (typeof callback === 'function') {
+ callback(error instanceof Error ? error : new Error(error));
+ }
+
+ git._getLog('error', error);
+ };
+
+ module.exports = Git;
+
+ /**
+ * Requires and returns a response handler based on its named type
+ * @param {string} type
+ */
+ function requireResponseHandler (type) {
+ return responses[type];
+ }
+
+}());
diff --git a/node_modules/simple-git/src/index.js b/node_modules/simple-git/src/index.js
new file mode 100644
index 00000000..211dcccf
--- /dev/null
+++ b/node_modules/simple-git/src/index.js
@@ -0,0 +1,14 @@
+
+var Git = require('./git');
+
+module.exports = function (baseDir) {
+
+ var dependencies = require('./util/dependencies');
+
+ if (baseDir && !dependencies.exists(baseDir, dependencies.exists.FOLDER)) {
+ throw new Error("Cannot use simple-git on a directory that does not exist.");
+ }
+
+ return new Git(baseDir || process.cwd(), dependencies.childProcess(), dependencies.buffer());
+};
+
diff --git a/node_modules/simple-git/src/responses/BranchDeleteSummary.js
b/node_modules/simple-git/src/responses/BranchDeleteSummary.js
new file mode 100644
index 00000000..d79bdc1d
--- /dev/null
+++ b/node_modules/simple-git/src/responses/BranchDeleteSummary.js
@@ -0,0 +1,26 @@
+
+module.exports = BranchDeletion;
+
+function BranchDeletion (branch, hash) {
+ this.branch = branch;
+ this.hash = hash;
+ this.success = hash !== null;
+}
+
+BranchDeletion.deleteSuccessRegex = /(\S+)\s+\(\S+\s([^\)]+)\)/;
+BranchDeletion.deleteErrorRegex = /^error[^']+'([^']+)'/;
+
+BranchDeletion.parse = function (data, asArray) {
+ var result;
+ var branchDeletions = data.trim().split('\n').map(function (line) {
+ if (result = BranchDeletion.deleteSuccessRegex.exec(line)) {
+ return new BranchDeletion(result[1], result[2]);
+ }
+ else if (result = BranchDeletion.deleteErrorRegex.exec(line)) {
+ return new BranchDeletion(result[1], null);
+ }
+ })
+ .filter(Boolean);
+
+ return asArray ? branchDeletions : branchDeletions.pop();
+};
diff --git a/node_modules/simple-git/src/responses/BranchSummary.js
b/node_modules/simple-git/src/responses/BranchSummary.js
new file mode 100644
index 00000000..260e9d1b
--- /dev/null
+++ b/node_modules/simple-git/src/responses/BranchSummary.js
@@ -0,0 +1,52 @@
+
+module.exports = BranchSummary;
+
+function BranchSummary () {
+ this.detached = false;
+ this.current = '';
+ this.all = [];
+ this.branches = {};
+}
+
+BranchSummary.prototype.push = function (current, detached, name, commit, label) {
+ if (current) {
+ this.detached = detached;
+ this.current = name;
+ }
+ this.all.push(name);
+ this.branches[name] = {
+ current: current,
+ name: name,
+ commit: commit,
+ label: label
+ };
+};
+
+BranchSummary.detachedRegex = /^(\*?\s+)\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/;
+BranchSummary.branchRegex = /^(\*?\s+)(\S+)\s+([a-z0-9]+)\s(.*)$/;
+
+BranchSummary.parse = function (commit) {
+ var branchSummary = new BranchSummary();
+
+ commit.split('\n')
+ .forEach(function (line) {
+ var detached = true;
+ var branch = BranchSummary.detachedRegex.exec(line);
+ if (!branch) {
+ detached = false;
+ branch = BranchSummary.branchRegex.exec(line);
+ }
+
+ if (branch) {
+ branchSummary.push(
+ branch[1].charAt(0) === '*',
+ detached,
+ branch[2],
+ branch[3],
+ branch[4]
+ );
+ }
+ });
+
+ return branchSummary;
+};
diff --git a/node_modules/simple-git/src/responses/CommitSummary.js
b/node_modules/simple-git/src/responses/CommitSummary.js
new file mode 100644
index 00000000..052aadb5
--- /dev/null
+++ b/node_modules/simple-git/src/responses/CommitSummary.js
@@ -0,0 +1,60 @@
+
+module.exports = CommitSummary;
+
+function CommitSummary () {
+ this.branch = '';
+ this.commit = '';
+ this.summary = {
+ changes: 0,
+ insertions: 0,
+ deletions: 0
+ };
+ this.author = null;
+}
+
+var COMMIT_BRANCH_MESSAGE_REGEX = /\[([^\s]+) ([^\]]+)/;
+var COMMIT_AUTHOR_MESSAGE_REGEX = /\s*Author:\s(.+)/i;
+
+function setBranchFromCommit (commitSummary, commitData) {
+ if (commitData) {
+ commitSummary.branch = commitData[1];
+ commitSummary.commit = commitData[2];
+ }
+}
+
+function setSummaryFromCommit (commitSummary, commitData) {
+ if (commitSummary.branch && commitData) {
+ commitSummary.summary.changes = commitData[1] || 0;
+ commitSummary.summary.insertions = commitData[2] || 0;
+ commitSummary.summary.deletions = commitData[3] || 0;
+ }
+}
+
+function setAuthorFromCommit (commitSummary, commitData) {
+ var parts = commitData[1].split('<');
+ var email = parts.pop();
+
+ if (email.indexOf('@') <= 0) {
+ return;
+ }
+
+ commitSummary.author = {
+ email: email.substr(0, email.length - 1),
+ name: parts.join('<').trim()
+ };
+}
+
+CommitSummary.parse = function (commit) {
+ var lines = commit.trim().split('\n');
+ var commitSummary = new CommitSummary();
+
+ setBranchFromCommit(commitSummary, COMMIT_BRANCH_MESSAGE_REGEX.exec(lines.shift()));
+
+ if (COMMIT_AUTHOR_MESSAGE_REGEX.test(lines[0])) {
+ setAuthorFromCommit(commitSummary, COMMIT_AUTHOR_MESSAGE_REGEX.exec(lines.shift()));
+ }
+
+ setSummaryFromCommit(commitSummary, /(\d+)[^,]*(?:,\s*(\d+)[^,]*)?(?:,\s*(\d+))?/g.exec(lines.shift()));
+
+ return commitSummary;
+};
diff --git a/node_modules/simple-git/src/responses/DiffSummary.js
b/node_modules/simple-git/src/responses/DiffSummary.js
new file mode 100644
index 00000000..64ef80e8
--- /dev/null
+++ b/node_modules/simple-git/src/responses/DiffSummary.js
@@ -0,0 +1,92 @@
+
+module.exports = DiffSummary;
+
+/**
+ * The DiffSummary is returned as a response to getting `git().status()`
+ *
+ * @constructor
+ */
+function DiffSummary () {
+ this.files = [];
+ this.insertions = 0;
+ this.deletions = 0;
+ this.changed = 0;
+}
+
+/**
+ * Number of lines added
+ * @type {number}
+ */
+DiffSummary.prototype.insertions = 0;
+
+/**
+ * Number of lines deleted
+ * @type {number}
+ */
+DiffSummary.prototype.deletions = 0;
+
+/**
+ * Number of files changed
+ * @type {number}
+ */
+DiffSummary.prototype.changed = 0;
+
+DiffSummary.parse = function (text) {
+ var line, handler;
+
+ var lines = text.trim().split('\n');
+ var status = new DiffSummary();
+
+ var summary = lines.pop();
+ if (summary) {
+ summary.trim().split(', ').forEach(function (text) {
+ var summary = /(\d+)\s([a-z]+)/.exec(text);
+ if (!summary) {
+ return;
+ }
+
+ if (/files?/.test(summary[2])) {
+ status.changed = parseInt(summary[1], 10);
+ }
+ else {
+ status[summary[2].replace(/s$/, '') + 's'] = parseInt(summary[1], 10);
+ }
+ });
+ }
+
+ while (line = lines.shift()) {
+ textFileChange(line, status.files) || binaryFileChange(line, status.files);
+ }
+
+ return status;
+};
+
+function textFileChange (line, files) {
+ line = line.trim().match(/^(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/);
+
+ if (line) {
+ var alterations = (line[3] || '').trim();
+ files.push({
+ file: line[1].trim(),
+ changes: parseInt(line[2], 10),
+ insertions: alterations.replace(/-/g, '').length,
+ deletions: alterations.replace(/\+/g, '').length,
+ binary: false
+ });
+
+ return true;
+ }
+}
+
+function binaryFileChange (line, files) {
+ line = line.match(/^(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)$/);
+ if (line) {
+ files.push({
+ file: line[1].trim(),
+ before: +line[2],
+ after: +line[3],
+ binary: true
+ });
+ return true;
+ }
+}
diff --git a/node_modules/simple-git/src/responses/FetchSummary.js
b/node_modules/simple-git/src/responses/FetchSummary.js
new file mode 100644
index 00000000..7c8f0c95
--- /dev/null
+++ b/node_modules/simple-git/src/responses/FetchSummary.js
@@ -0,0 +1,55 @@
+'use strict';
+
+function FetchSummary (raw) {
+ this.raw = raw;
+
+ this.remote = null;
+ this.branches = [];
+ this.tags = [];
+}
+
+FetchSummary.parsers = [
+ [
+ /From (.+)$/, function (fetchSummary, matches) {
+ fetchSummary.remote = matches[0];
+ }
+ ],
+ [
+ /\* \[new branch\]\s+(\S+)\s*\-> (.+)$/, function (fetchSummary, matches) {
+ fetchSummary.branches.push({
+ name: matches[0],
+ tracking: matches[1]
+ });
+ }
+ ],
+ [
+ /\* \[new tag\]\s+(\S+)\s*\-> (.+)$/, function (fetchSummary, matches) {
+ fetchSummary.tags.push({
+ name: matches[0],
+ tracking: matches[1]
+ });
+ }
+ ]
+];
+
+FetchSummary.parse = function (data) {
+ var fetchSummary = new FetchSummary(data);
+
+ String(data)
+ .trim()
+ .split('\n')
+ .forEach(function (line) {
+ var original = line.trim();
+ FetchSummary.parsers.some(function (parser) {
+ var parsed = parser[0].exec(original);
+ if (parsed) {
+ parser[1](fetchSummary, parsed.slice(1));
+ return true;
+ }
+ });
+ });
+
+ return fetchSummary;
+};
+
+module.exports = FetchSummary;
diff --git a/node_modules/simple-git/src/responses/FileStatusSummary.js
b/node_modules/simple-git/src/responses/FileStatusSummary.js
new file mode 100644
index 00000000..c2ac287a
--- /dev/null
+++ b/node_modules/simple-git/src/responses/FileStatusSummary.js
@@ -0,0 +1,22 @@
+'use strict';
+
+function FileStatusSummary (path, index, working_dir) {
+ this.path = path;
+ this.index = index;
+ this.working_dir = working_dir;
+
+ if ('R' === index + working_dir) {
+ var detail = FileStatusSummary.fromPathRegex.exec(path) || [null, path, path];
+ this.from = detail[1];
+ this.path = detail[2];
+ }
+}
+
+FileStatusSummary.fromPathRegex = /^(.+) -> (.+)$/;
+
+FileStatusSummary.prototype = {
+ path: '',
+ from: ''
+};
+
+module.exports = FileStatusSummary;
diff --git a/node_modules/simple-git/src/responses/ListLogSummary.js
b/node_modules/simple-git/src/responses/ListLogSummary.js
new file mode 100644
index 00000000..53a97f5d
--- /dev/null
+++ b/node_modules/simple-git/src/responses/ListLogSummary.js
@@ -0,0 +1,72 @@
+
+module.exports = ListLogSummary;
+
+var DiffSummary = require('./DiffSummary');
+
+/**
+ * The ListLogSummary is returned as a response to getting `git().log()` or `git().stashList()`
+ *
+ * @constructor
+ */
+function ListLogSummary (all) {
+ this.all = all;
+ this.latest = all.length && all[0] || null;
+ this.total = all.length;
+}
+
+/**
+ * Detail for each of the log lines
+ * @type {ListLogLine[]}
+ */
+ListLogSummary.prototype.all = null;
+
+/**
+ * Most recent entry in the log
+ * @type {ListLogLine}
+ */
+ListLogSummary.prototype.latest = null;
+
+/**
+ * Number of items in the log
+ * @type {number}
+ */
+ListLogSummary.prototype.total = 0;
+
+function ListLogLine (line, fields) {
+ for (var k = 0; k < fields.length; k++) {
+ this[fields[k]] = line[k] || '';
+ }
+}
+
+/**
+ * When the log was generated with a summary, the `diff` property contains as much detail
+ * as was provided in the log (whether generated with `--stat` or `--shortstat`.
+ * @type {DiffSummary}
+ */
+ListLogLine.prototype.diff = null;
+
+ListLogSummary.START_BOUNDARY = 'òòòòòò ';
+
+ListLogSummary.COMMIT_BOUNDARY = ' òò';
+
+ListLogSummary.SPLITTER = ' ò ';
+
+ListLogSummary.parse = function (text, splitter, fields) {
+ fields = fields || ['hash', 'date', 'message', 'refs', 'author_name', 'author_email'];
+ return new ListLogSummary(
+ text
+ .trim()
+ .split(ListLogSummary.START_BOUNDARY)
+ .filter(function(item) { return !!item.trim(); })
+ .map(function (item) {
+ var lineDetail = item.trim().split(ListLogSummary.COMMIT_BOUNDARY);
+ var listLogLine = new ListLogLine(lineDetail[0].trim().split(splitter), fields);
+
+ if (lineDetail.length > 1 && !!lineDetail[1].trim()) {
+ listLogLine.diff = DiffSummary.parse(lineDetail[1]);
+ }
+
+ return listLogLine;
+ })
+ );
+};
diff --git a/node_modules/simple-git/src/responses/MergeSummary.js
b/node_modules/simple-git/src/responses/MergeSummary.js
new file mode 100644
index 00000000..2858cf73
--- /dev/null
+++ b/node_modules/simple-git/src/responses/MergeSummary.js
@@ -0,0 +1,103 @@
+module.exports = MergeSummary;
+module.exports.MergeConflict = MergeConflict;
+
+var PullSummary = require('./PullSummary');
+
+function MergeConflict (reason, file, meta) {
+ this.reason = reason;
+ this.file = file;
+ if (meta) {
+ this.meta = meta;
+ }
+}
+
+MergeConflict.prototype.meta = null;
+
+MergeConflict.prototype.toString = function () {
+ return this.file + ':' + this.reason;
+};
+
+function MergeSummary () {
+ PullSummary.call(this);
+
+ this.conflicts = [];
+ this.merges = [];
+}
+
+MergeSummary.prototype = Object.create(PullSummary.prototype);
+
+MergeSummary.prototype.result = 'success';
+
+MergeSummary.prototype.toString = function () {
+ if (this.conflicts.length) {
+ return 'CONFLICTS: ' + this.conflicts.join(', ');
+ }
+ return 'OK';
+};
+
+Object.defineProperty(MergeSummary.prototype, 'failed', {
+ get: function () {
+ return this.conflicts.length > 0;
+ }
+});
+
+MergeSummary.parsers = [
+ {
+ test: /^Auto-merging\s+(.+)$/,
+ handle: function (result, mergeSummary) {
+ mergeSummary.merges.push(result[1]);
+ }
+ },
+ {
+ // Parser for standard merge conflicts
+ test: /^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/,
+ handle: function (result, mergeSummary) {
+ mergeSummary.conflicts.push(new MergeConflict(result[1], result[2]));
+ }
+ },
+ {
+ // Parser for modify/delete merge conflicts (modified by us/them, deleted by them/us)
+ test: /^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/,
+ handle: function (result, mergeSummary) {
+ mergeSummary.conflicts.push(
+ new MergeConflict(result[1], result[2], {deleteRef: result[3]})
+ );
+ }
+ },
+ {
+ // Catch-all parser for unknown/unparsed conflicts
+ test: /^CONFLICT\s+\((.+)\):/,
+ handle: function (result, mergeSummary) {
+ mergeSummary.conflicts.push(new MergeConflict(result[1], null));
+ }
+ },
+ {
+ test: /^Automatic merge failed;\s+(.+)$/,
+ handle: function (result, mergeSummary) {
+ mergeSummary.reason = mergeSummary.result = result[1];
+ }
+ }
+];
+
+MergeSummary.parse = function (output) {
+ let mergeSummary = new MergeSummary();
+
+ output.trim().split('\n').forEach(function (line) {
+ for (var i = 0, iMax = MergeSummary.parsers.length; i < iMax; i++) {
+ let parser = MergeSummary.parsers[i];
+
+ var result = parser.test.exec(line);
+ if (result) {
+ parser.handle(result, mergeSummary);
+ break;
+ }
+ }
+ });
+
+ let pullSummary = PullSummary.parse(output);
+ if (pullSummary.summary.changes) {
+ Object.assign(mergeSummary, pullSummary);
+ }
+
+ return mergeSummary;
+};
diff --git a/node_modules/simple-git/src/responses/MoveSummary.js
b/node_modules/simple-git/src/responses/MoveSummary.js
new file mode 100644
index 00000000..4a0198c2
--- /dev/null
+++ b/node_modules/simple-git/src/responses/MoveSummary.js
@@ -0,0 +1,32 @@
+
+module.exports = MoveSummary;
+
+/**
+ * The MoveSummary is returned as a response to getting `git().status()`
+ *
+ * @constructor
+ */
+function MoveSummary () {
+ this.moves = [];
+ this.sources = {};
+}
+
+MoveSummary.SUMMARY_REGEX = /^Renaming (.+) to (.+)$/;
+
+MoveSummary.parse = function (text) {
+ var lines = text.split('\n');
+ var summary = new MoveSummary();
+
+ for (var i = 0, iMax = lines.length, line; i < iMax; i++) {
+ line = MoveSummary.SUMMARY_REGEX.exec(lines[i].trim());
+
+ if (line) {
+ summary.moves.push({
+ from: line[1],
+ to: line[2]
+ });
+ }
+ }
+
+ return summary;
+};
diff --git a/node_modules/simple-git/src/responses/PullSummary.js
b/node_modules/simple-git/src/responses/PullSummary.js
new file mode 100644
index 00000000..5e444e26
--- /dev/null
+++ b/node_modules/simple-git/src/responses/PullSummary.js
@@ -0,0 +1,137 @@
+
+module.exports = PullSummary;
+
+/**
+ * The PullSummary is returned as a response to getting `git().pull()`
+ *
+ * @constructor
+ */
+function PullSummary () {
+ this.files = [];
+ this.insertions = {};
+ this.deletions = {};
+
+ this.summary = {
+ changes: 0,
+ insertions: 0,
+ deletions: 0
+ };
+
+ this.created = [];
+ this.deleted = [];
+}
+
+/**
+ * Array of files that were created
+ * @type {string[]}
+ */
+PullSummary.prototype.created = null;
+
+/**
+ * Array of files that were deleted
+ * @type {string[]}
+ */
+PullSummary.prototype.deleted = null;
+
+/**
+ * The array of file paths/names that have been modified in any part of the pulled content
+ * @type {string[]}
+ */
+PullSummary.prototype.files = null;
+
+/**
+ * A map of file path to number to show the number of insertions per file.
+ * @type {Object}
+ */
+PullSummary.prototype.insertions = null;
+
+/**
+ * A map of file path to number to show the number of deletions per file.
+ * @type {Object}
+ */
+PullSummary.prototype.deletions = null;
+
+/**
+ * Overall summary of changes/insertions/deletions and the number associated with each
+ * across all content that was pulled.
+ * @type {Object}
+ */
+PullSummary.prototype.summary = null;
+
+PullSummary.FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/;
+PullSummary.SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/;
+PullSummary.ACTION_REGEX = /(create|delete) mode \d+ (.+)/;
+
+PullSummary.parse = function (text) {
+ var pullSummary = new PullSummary;
+ var lines = text.split('\n');
+
+ while (lines.length) {
+ var line = lines.shift().trim();
+ if (!line) {
+ continue;
+ }
+
+ update(pullSummary, line) || summary(pullSummary, line) || action(pullSummary, line);
+ }
+
+ return pullSummary;
+};
+
+function update (pullSummary, line) {
+
+ var update = PullSummary.FILE_UPDATE_REGEX.exec(line);
+ if (!update) {
+ return false;
+ }
+
+ pullSummary.files.push(update[1]);
+
+ var insertions = update[2].length;
+ if (insertions) {
+ pullSummary.insertions[update[1]] = insertions;
+ }
+
+ var deletions = update[3].length;
+ if (deletions) {
+ pullSummary.deletions[update[1]] = deletions;
+ }
+
+ return true;
+}
+
+function summary (pullSummary, line) {
+ if (!pullSummary.files.length) {
+ return false;
+ }
+
+ var update = PullSummary.SUMMARY_REGEX.exec(line);
+ if (!update || (update[3] === undefined && update[5] === undefined)) {
+ return false;
+ }
+
+ pullSummary.summary.changes = +update[1] || 0;
+ pullSummary.summary.insertions = +update[3] || 0;
+ pullSummary.summary.deletions = +update[5] || 0;
+
+ return true;
+}
+
+function action (pullSummary, line) {
+
+ var match = PullSummary.ACTION_REGEX.exec(line);
+ if (!match) {
+ return false;
+ }
+
+ var file = match[2];
+
+ if (pullSummary.files.indexOf(file) < 0) {
+ pullSummary.files.push(file);
+ }
+
+ var container = (match[1] === 'create') ? pullSummary.created : pullSummary.deleted;
+ container.push(file);
+
+ return true;
+}
diff --git a/node_modules/simple-git/src/responses/StatusSummary.js
b/node_modules/simple-git/src/responses/StatusSummary.js
new file mode 100644
index 00000000..a495dd4f
--- /dev/null
+++ b/node_modules/simple-git/src/responses/StatusSummary.js
@@ -0,0 +1,188 @@
+
+
+
+var FileStatusSummary = require('./FileStatusSummary');
+
+module.exports = StatusSummary;
+
+/**
+ * The StatusSummary is returned as a response to getting `git().status()`
+ *
+ * @constructor
+ */
+function StatusSummary () {
+ this.not_added = [];
+ this.conflicted = [];
+ this.created = [];
+ this.deleted = [];
+ this.modified = [];
+ this.renamed = [];
+ this.files = [];
+ this.staged = [];
+}
+
+
+/**
+ * Number of commits ahead of the tracked branch
+ * @type {number}
+ */
+StatusSummary.prototype.ahead = 0;
+
+/**
+ * Number of commits behind the tracked branch
+ * @type {number}
+ */
+StatusSummary.prototype.behind = 0;
+
+/**
+ * Name of the current branch
+ * @type {null}
+ */
+StatusSummary.prototype.current = null;
+
+/**
+ * Name of the branch being tracked
+ * @type {string}
+ */
+StatusSummary.prototype.tracking = null;
+
+/**
+ * All files represented as an array of objects containing the `path` and status in `index` and
+ * in the `working_dir`.
+ *
+ * @type {Array}
+ */
+StatusSummary.prototype.files = null;
+
+/**
+ * Gets whether this StatusSummary represents a clean working branch.
+ *
+ * @return {boolean}
+ */
+StatusSummary.prototype.isClean = function () {
+ return 0 === Object.keys(this).filter(function (name) {
+ return Array.isArray(this[name]) && this[name].length;
+ }, this).length;
+};
+
+StatusSummary.parsers = {
+ '##': function (line, status) {
+ var aheadReg = /ahead (\d+)/;
+ var behindReg = /behind (\d+)/;
+ var currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/;
+ var trackingReg = /\.{3}(\S*)/;
+ var regexResult;
+
+ regexResult = aheadReg.exec(line);
+ status.ahead = regexResult && +regexResult[1] || 0;
+
+ regexResult = behindReg.exec(line);
+ status.behind = regexResult && +regexResult[1] || 0;
+
+ regexResult = currentReg.exec(line);
+ status.current = regexResult && regexResult[1];
+
+ regexResult = trackingReg.exec(line);
+ status.tracking = regexResult && regexResult[1];
+ },
+
+ '??': function (line, status) {
+ status.not_added.push(line);
+ },
+
+ A: function (line, status) {
+ status.created.push(line);
+ },
+
+ AM: function (line, status) {
+ status.created.push(line);
+ },
+
+ D: function (line, status) {
+ status.deleted.push(line);
+ },
+
+ M: function (line, status, indexState) {
+ status.modified.push(line);
+
+ if (indexState === 'M') {
+ status.staged.push(line);
+ }
+ },
+
+ R: function (line, status) {
+ var detail = /^(.+) -> (.+)$/.exec(line) || [null, line, line];
+
+ status.renamed.push({
+ from: detail[1],
+ to: detail[2]
+ });
+ },
+
+ UU: function (line, status) {
+ status.conflicted.push(line);
+ }
+};
+
+StatusSummary.parsers.MM = StatusSummary.parsers.M;
+
+/* Map all unmerged status code combinations to UU to mark as conflicted */
+StatusSummary.parsers.AA = StatusSummary.parsers.UU;
+StatusSummary.parsers.UD = StatusSummary.parsers.UU;
+StatusSummary.parsers.DU = StatusSummary.parsers.UU;
+StatusSummary.parsers.DD = StatusSummary.parsers.UU;
+StatusSummary.parsers.AU = StatusSummary.parsers.UU;
+StatusSummary.parsers.UA = StatusSummary.parsers.UU;
+
+StatusSummary.parse = function (text) {
+ var file;
+ var lines = text.trim().split('\n');
+ var status = new StatusSummary();
+
+ for (var i = 0, l = lines.length; i < l; i++) {
+ file = splitLine(lines[i]);
+
+ if (!file) {
+ continue;
+ }
+
+ if (file.handler) {
+ file.handler(file.path, status, file.index, file.workingDir);
+ }
+
+ if (file.code !== '##') {
+ status.files.push(new FileStatusSummary(file.path, file.index, file.workingDir));
+ }
+ }
+
+ return status;
+};
+
+
+function splitLine (lineStr) {
+ var line = lineStr.trim().match(/(..?)(\s+)(.*)/);
+ if (!line || !line[1].trim()) {
+ line = lineStr.trim().match(/(..?)\s+(.*)/);
+ }
+
+ if (!line) {
+ return;
+ }
+
+ var code = line[1];
+ if (line[2].length > 1) {
+ code += ' ';
+ }
+ if (code.length === 1 && line[2].length === 1) {
+ code = ' ' + code;
+ }
+
+ return {
+ raw: code,
+ code: code.trim(),
+ index: code.charAt(0),
+ workingDir: code.charAt(1),
+ handler: StatusSummary.parsers[code.trim()],
+ path: line[3]
+ };
+}
diff --git a/node_modules/simple-git/src/responses/TagList.js
b/node_modules/simple-git/src/responses/TagList.js
new file mode 100644
index 00000000..3ecbc9e7
--- /dev/null
+++ b/node_modules/simple-git/src/responses/TagList.js
@@ -0,0 +1,50 @@
+
+module.exports = TagList;
+
+function TagList (tagList, latest) {
+ this.latest = latest;
+ this.all = tagList
+}
+
+TagList.parse = function (data, customSort) {
+ var number = function (input) {
+ if (typeof input === 'string') {
+ return parseInt(input.replace(/^\D+/g, ''), 10) || 0;
+ }
+
+ return 0;
+ };
+
+ var tags = data
+ .trim()
+ .split('\n')
+ .map(function (item) { return item.trim(); })
+ .filter(Boolean);
+
+ if (!customSort) {
+ tags.sort(function (tagA, tagB) {
+ var partsA = tagA.split('.');
+ var partsB = tagB.split('.');
+
+ if (partsA.length === 1 || partsB.length === 1) {
+ return tagA - tagB > 0 ? 1 : -1;
+ }
+
+ for (var i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) {
+ var a = number(partsA[i]);
+ var b = number(partsB[i]);
+
+ var diff = a - b;
+ if (diff) {
+ return diff > 0 ? 1 : -1;
+ }
+ }
+
+ return 0;
+ });
+ }
+
+ var latest = customSort ? tags[0] : tags.filter(function (tag) { return tag.indexOf('.') >= 0; }).pop();
+
+ return new TagList(tags, latest);
+};
diff --git a/node_modules/simple-git/src/responses/index.js b/node_modules/simple-git/src/responses/index.js
new file mode 100644
index 00000000..802edda9
--- /dev/null
+++ b/node_modules/simple-git/src/responses/index.js
@@ -0,0 +1,15 @@
+
+module.exports = {
+ BranchDeleteSummary: require('./BranchDeleteSummary'),
+ BranchSummary: require('./BranchSummary'),
+ CommitSummary: require('./CommitSummary'),
+ DiffSummary: require('./DiffSummary'),
+ FetchSummary: require('./FetchSummary'),
+ FileStatusSummary: require('./FileStatusSummary'),
+ ListLogSummary: require('./ListLogSummary'),
+ MergeSummary: require('./MergeSummary'),
+ MoveSummary: require('./MoveSummary'),
+ PullSummary: require('./PullSummary'),
+ StatusSummary: require('./StatusSummary'),
+ TagList: require('./TagList'),
+};
diff --git a/node_modules/simple-git/src/util/deferred.js b/node_modules/simple-git/src/util/deferred.js
new file mode 100644
index 00000000..314452a2
--- /dev/null
+++ b/node_modules/simple-git/src/util/deferred.js
@@ -0,0 +1,10 @@
+
+module.exports = function deferred () {
+ var d = {};
+ d.promise = new Promise(function (resolve, reject) {
+ d.resolve = resolve;
+ d.reject = reject
+ });
+
+ return d;
+};
diff --git a/node_modules/simple-git/src/util/dependencies.js
b/node_modules/simple-git/src/util/dependencies.js
new file mode 100644
index 00000000..27805ed9
--- /dev/null
+++ b/node_modules/simple-git/src/util/dependencies.js
@@ -0,0 +1,12 @@
+/**
+ * Exports the utilities `simple-git` depends upon to allow for mocking during a test
+ */
+module.exports = {
+
+ buffer: function () { return require('buffer').Buffer; },
+
+ childProcess: function () { return require('child_process'); },
+
+ exists: require('./exists')
+
+};
diff --git a/node_modules/simple-git/src/util/exists.js b/node_modules/simple-git/src/util/exists.js
new file mode 100644
index 00000000..e48fc100
--- /dev/null
+++ b/node_modules/simple-git/src/util/exists.js
@@ -0,0 +1,33 @@
+
+var fs = require('fs');
+
+function exists (path, isFile, isDirectory) {
+ try {
+ var matches = false;
+ var stat = fs.statSync(path);
+
+ matches = matches || isFile && stat.isFile();
+ matches = matches || isDirectory && stat.isDirectory();
+
+ return matches;
+ }
+ catch (e) {
+ if (e.code === 'ENOENT') {
+ return false;
+ }
+
+ throw e;
+ }
+}
+
+module.exports = function (path, type) {
+ if (!type) {
+ return exists(path, true, true);
+ }
+
+ return exists(path, type & 1, type & 2);
+};
+
+module.exports.FILE = 1;
+
+module.exports.FOLDER = 2;
diff --git a/node_modules/simple-git/typings/response.d.ts b/node_modules/simple-git/typings/response.d.ts
new file mode 100644
index 00000000..2d36b5b7
--- /dev/null
+++ b/node_modules/simple-git/typings/response.d.ts
@@ -0,0 +1,220 @@
+export interface BranchDeletionSummary {
+ branch: string;
+ hash: any;
+ success: boolean;
+}
+
+export interface BranchSummary {
+ detached: boolean;
+ current: string;
+ all: string[];
+ branches: {
+ [key: string]: {
+ current: boolean;
+ name: string;
+ commit: string;
+ label: string;
+ };
+ };
+}
+
+export interface CommitSummary {
+ author: null | {
+ email: string;
+ name: string;
+ };
+ branch: string;
+ commit: string;
+ summary: {
+ changes: number;
+ insertions: number;
+ deletions: number;
+ };
+}
+
+export interface DiffResultTextFile {
+ file: string;
+ changes: number;
+ insertions: number;
+ deletions: number;
+ binary: boolean;
+}
+
+export interface DiffResultBinaryFile {
+ file: string;
+ before: number;
+ after: number;
+ binary: boolean;
+}
+
+export interface DiffResult {
+ /** The total number of files changed as reported in the summary line */
+ changed: number;
+
+ /** When present in the diff, lists the details of each file changed */
+ files: Array<DiffResultTextFile | DiffResultBinaryFile>;
+
+ /** The number of files changed with insertions */
+ insertions: number;
+
+ /** The number of files changed with deletions */
+ deletions: number;
+}
+
+export interface FetchResult {
+ raw: string;
+ remote: string | null;
+ branches: {
+ name: string;
+ tracking: string;
+ }[];
+ tags: {
+ name: string;
+ tracking: string;
+ }[];
+}
+
+export interface MoveSummary {
+ moves: any[];
+}
+
+export interface PullResult {
+ /** Array of all files that are referenced in the pull */
+ files: string[];
+
+ /** Map of file names to the number of insertions in that file */
+ insertions: { [key: string]: number };
+
+ /** Map of file names to the number of deletions in that file */
+ deletions: any;
+
+ summary: {
+ changes: number;
+ insertions: number;
+ deletions: number;
+ };
+
+ /** Array of file names that have been created */
+ created: string[];
+
+ /** Array of file names that have been deleted */
+ deleted: string[];
+}
+
+export interface RemoteWithoutRefs {
+ name: string;
+}
+
+export interface RemoteWithRefs extends RemoteWithoutRefs {
+ refs: {
+ fetch: string;
+ push: string;
+ };
+}
+
+export interface StatusResultRenamed {
+ from: string;
+ to: string;
+}
+
+export interface FileStatusSumary {
+ /* Path of the file */
+ path: string;
+ /* First digit of the status code of the file, e.g. 'M' = modified.
+ Represents the status of the index if no merge conflicts, otherwise represents
+ status of one side of the merge. */
+ index: string;
+ /* Second digit of the status code of the file. Represents status of the working directory
+ if no merge conflicts, otherwise represents status of other side of a merge. */
+ working_dir: string;
+}
+
+export interface StatusResult {
+ not_added: string[];
+ conflicted: string[];
+ created: string[];
+ deleted: string[];
+ modified: string[];
+ renamed: StatusResultRenamed[];
+ staged: string[];
+ files: FileStatusSumary[];
+ ahead: number;
+ behind: number;
+ current: string;
+ tracking: string;
+
+ /**
+ * Gets whether this represents a clean working branch.
+ */
+ isClean(): boolean;
+}
+
+export interface TagResult {
+ all: string[];
+ latest: string;
+}
+
+export interface DefaultLogFields {
+ hash: string;
+ date: string;
+ message: string;
+ refs: string;
+ body: string;
+ author_name: string;
+ author_email: string;
+}
+
+/**
+ * The ListLogLine represents a single entry in the `git.log`, the properties on the object
+ * are mixed in depending on the names used in the format (see `DefaultLogFields`), but some
+ * properties are dependent on the command used.
+ */
+export interface ListLogLine {
+ /**
+ * When using a `--stat=4096` or `--shortstat` options in the `git.log` or `git.stashList`,
+ * each entry in the `ListLogSummary` will also have a `diff` property representing as much
+ * detail as was given in the response.
+ */
+ diff?: DiffResult;
+}
+
+export interface ListLogSummary<T = DefaultLogFields> {
+ all: ReadonlyArray<T & ListLogLine>;
+ total: number;
+ latest: T & ListLogLine;
+}
+
+/**
+ * Where the file was deleted, if there is a modify/delete conflict
+ */
+export interface MergeConflictDeletion {
+ deleteRef: string;
+}
+
+/**
+ * Represents a single file with conflicts in the MergeSummary
+ */
+export interface MergeConflict {
+
+ /**
+ * Type of conflict
+ */
+ reason: string;
+
+ /**
+ * Path to file
+ */
+ file: string;
+
+ /**
+ * Additional detail for the specific type of conflict
+ */
+ meta?: MergeConflictDeletion;
+}
+
+export interface MergeSummary extends PullResult {
+ conflicts: MergeConflict[];
+ merges: string[];
+ result: "success" | string;
+ failed: boolean;
+}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
