krisyotam/devdocs

node_modules/eslint/lib/rules/no-underscore-dangle.js+0−277

@@ -1,277 +0,0 @@
1	/**
2	* @fileoverview Rule to flag dangling underscores in variable declarations.
3	* @author Matt DuVall <http://www.mattduvall.com>
4	*/
5
6	"use strict";
7
8	//------------------------------------------------------------------------------
9	// Rule Definition
10	//------------------------------------------------------------------------------
11
12	module.exports = {
13	meta: {
14	type: "suggestion",
15
16	docs: {
17	description: "disallow dangling underscores in identifiers",
18	category: "Stylistic Issues",
19	recommended: false,
20	url: "https://eslint.org/docs/rules/no-underscore-dangle"
21	},
22
23	schema: [
24	{
25	type: "object",
26	properties: {
27	allow: {
28	type: "array",
29	items: {
30	type: "string"
31	}
32	},
33	allowAfterThis: {
34	type: "boolean",
35	default: false
36	},
37	allowAfterSuper: {
38	type: "boolean",
39	default: false
40	},
41	allowAfterThisConstructor: {
42	type: "boolean",
43	default: false
44	},
45	enforceInMethodNames: {
46	type: "boolean",
47	default: false
48	},
49	allowFunctionParams: {
50	type: "boolean",
51	default: true
52	}
53	},
54	additionalProperties: false
55	}
56	],
57
58	messages: {
59	unexpectedUnderscore: "Unexpected dangling '_' in '{{identifier}}'."
60	}
61	},
62
63	create(context) {
64
65	const options = context.options[0] \|\| {};
66	const ALLOWED_VARIABLES = options.allow ? options.allow : [];
67	const allowAfterThis = typeof options.allowAfterThis !== "undefined" ? options.allowAfterThis : false;
68	const allowAfterSuper = typeof options.allowAfterSuper !== "undefined" ? options.allowAfterSuper : false;
69	const allowAfterThisConstructor = typeof options.allowAfterThisConstructor !== "undefined" ? options.allowAfterThisConstructor : false;
70	const enforceInMethodNames = typeof options.enforceInMethodNames !== "undefined" ? options.enforceInMethodNames : false;
71	const allowFunctionParams = typeof options.allowFunctionParams !== "undefined" ? options.allowFunctionParams : true;
72
73	//-------------------------------------------------------------------------
74	// Helpers
75	//-------------------------------------------------------------------------
76
77	/**
78	* Check if identifier is present inside the allowed option
79	* @param {string} identifier name of the node
80	* @returns {boolean} true if its is present
81	* @private
82	*/
83	function isAllowed(identifier) {
84	return ALLOWED_VARIABLES.some(ident => ident === identifier);
85	}
86
87	/**
88	* Check if identifier has a dangling underscore
89	* @param {string} identifier name of the node
90	* @returns {boolean} true if its is present
91	* @private
92	*/
93	function hasDanglingUnderscore(identifier) {
94	const len = identifier.length;
95
96	return identifier !== "_" && (identifier[0] === "_" \|\| identifier[len - 1] === "_");
97	}
98
99	/**
100	* Check if identifier is a special case member expression
101	* @param {string} identifier name of the node
102	* @returns {boolean} true if its is a special case
103	* @private
104	*/
105	function isSpecialCaseIdentifierForMemberExpression(identifier) {
106	return identifier === "__proto__";
107	}
108
109	/**
110	* Check if identifier is a special case variable expression
111	* @param {string} identifier name of the node
112	* @returns {boolean} true if its is a special case
113	* @private
114	*/
115	function isSpecialCaseIdentifierInVariableExpression(identifier) {
116
117	// Checks for the underscore library usage here
118	return identifier === "_";
119	}
120
121	/**
122	* Check if a node is a member reference of this.constructor
123	* @param {ASTNode} node node to evaluate
124	* @returns {boolean} true if it is a reference on this.constructor
125	* @private
126	*/
127	function isThisConstructorReference(node) {
128	return node.object.type === "MemberExpression" &&
129	node.object.property.name === "constructor" &&
130	node.object.object.type === "ThisExpression";
131	}
132
133	/**
134	* Check if function parameter has a dangling underscore.
135	* @param {ASTNode} node function node to evaluate
136	* @returns {void}
137	* @private
138	*/
139	function checkForDanglingUnderscoreInFunctionParameters(node) {
140	if (!allowFunctionParams) {
141	node.params.forEach(param => {
142	const { type } = param;
143	let nodeToCheck;
144
145	if (type === "RestElement") {
146	nodeToCheck = param.argument;
147	} else if (type === "AssignmentPattern") {
148	nodeToCheck = param.left;
149	} else {
150	nodeToCheck = param;
151	}
152
153	if (nodeToCheck.type === "Identifier") {
154	const identifier = nodeToCheck.name;
155
156	if (hasDanglingUnderscore(identifier) && !isAllowed(identifier)) {
157	context.report({
158	node: param,
159	messageId: "unexpectedUnderscore",
160	data: {
161	identifier
162	}
163	});
164	}
165	}
166	});
167	}
168	}
169
170	/**
171	* Check if function has a dangling underscore
172	* @param {ASTNode} node node to evaluate
173	* @returns {void}
174	* @private
175	*/
176	function checkForDanglingUnderscoreInFunction(node) {
177	if (node.type === "FunctionDeclaration" && node.id) {
178	const identifier = node.id.name;
179
180	if (typeof identifier !== "undefined" && hasDanglingUnderscore(identifier) && !isAllowed(identifier)) {
181	context.report({
182	node,
183	messageId: "unexpectedUnderscore",
184	data: {
185	identifier
186	}
187	});
188	}
189	}
190	checkForDanglingUnderscoreInFunctionParameters(node);
191	}
192
193	/**
194	* Check if variable expression has a dangling underscore
195	* @param {ASTNode} node node to evaluate
196	* @returns {void}
197	* @private
198	*/
199	function checkForDanglingUnderscoreInVariableExpression(node) {
200	const identifier = node.id.name;
201
202	if (typeof identifier !== "undefined" && hasDanglingUnderscore(identifier) &&
203	!isSpecialCaseIdentifierInVariableExpression(identifier) && !isAllowed(identifier)) {
204	context.report({
205	node,
206	messageId: "unexpectedUnderscore",
207	data: {
208	identifier
209	}
210	});
211	}
212	}
213
214	/**
215	* Check if member expression has a dangling underscore
216	* @param {ASTNode} node node to evaluate
217	* @returns {void}
218	* @private
219	*/
220	function checkForDanglingUnderscoreInMemberExpression(node) {
221	const identifier = node.property.name,
222	isMemberOfThis = node.object.type === "ThisExpression",
223	isMemberOfSuper = node.object.type === "Super",
224	isMemberOfThisConstructor = isThisConstructorReference(node);
225
226	if (typeof identifier !== "undefined" && hasDanglingUnderscore(identifier) &&
227	!(isMemberOfThis && allowAfterThis) &&
228	!(isMemberOfSuper && allowAfterSuper) &&
229	!(isMemberOfThisConstructor && allowAfterThisConstructor) &&
230	!isSpecialCaseIdentifierForMemberExpression(identifier) && !isAllowed(identifier)) {
231	context.report({
232	node,
233	messageId: "unexpectedUnderscore",
234	data: {
235	identifier
236	}
237	});
238	}
239	}
240
241	/**
242	* Check if method declaration or method property has a dangling underscore
243	* @param {ASTNode} node node to evaluate
244	* @returns {void}
245	* @private
246	*/
247	function checkForDanglingUnderscoreInMethod(node) {
248	const identifier = node.key.name;
249	const isMethod = node.type === "MethodDefinition" \|\| node.type === "Property" && node.method;
250
251	if (typeof identifier !== "undefined" && enforceInMethodNames && isMethod && hasDanglingUnderscore(identifier) && !isAllowed(identifier)) {
252	context.report({
253	node,
254	messageId: "unexpectedUnderscore",
255	data: {
256	identifier
257	}
258	});
259	}
260	}
261
262	//--------------------------------------------------------------------------
263	// Public API
264	//--------------------------------------------------------------------------
265
266	return {
267	FunctionDeclaration: checkForDanglingUnderscoreInFunction,
268	VariableDeclarator: checkForDanglingUnderscoreInVariableExpression,
269	MemberExpression: checkForDanglingUnderscoreInMemberExpression,
270	MethodDefinition: checkForDanglingUnderscoreInMethod,
271	Property: checkForDanglingUnderscoreInMethod,
272	FunctionExpression: checkForDanglingUnderscoreInFunction,
273	ArrowFunctionExpression: checkForDanglingUnderscoreInFunction
274	};
275
276	}
277	};

node_modules/fast-json-stable-stringify/.github/FUNDING.yml+0−1

@@ -1 +0,0 @@
1	tidelift: "npm/fast-json-stable-stringify"

node_modules/flatted/.github/FUNDING.yml+0−8

@@ -1,8 +0,0 @@
1	# These are supported funding model platforms
2
3	github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
4	patreon: # not working due missing www.
5	open_collective: #
6	ko_fi: # Replace with a single Ko-fi username
7	tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
8	custom: https://www.patreon.com/webreflection

node_modules/is-core-module/.github/FUNDING.yml+0−12

@@ -1,12 +0,0 @@
1	# These are supported funding model platforms
2
3	github: [ljharb]
4	patreon: # Replace with a single Patreon username
5	open_collective: # Replace with a single Open Collective username
6	ko_fi: # Replace with a single Ko-fi username
7	tidelift: npm/is-core-module
8	community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
9	liberapay: # Replace with a single Liberapay username
10	issuehunt: # Replace with a single IssueHunt username
11	otechie: # Replace with a single Otechie username
12	custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

node_modules/is-core-module/.github/workflows/node-4+.yml+0−54

@@ -1,54 +0,0 @@
1	name: 'Tests: node.js'
2
3	on: [pull_request, push]
4
5	jobs:
6	matrix:
7	runs-on: ubuntu-latest
8	outputs:
9	latest: ${{ steps.set-matrix.outputs.requireds }}
10	minors: ${{ steps.set-matrix.outputs.optionals }}
11	steps:
12	- uses: ljharb/actions/node/matrix@main
13	id: set-matrix
14	with:
15	preset: '>=4'
16
17	latest:
18	needs: [matrix]
19	name: 'latest minors'
20	runs-on: ubuntu-latest
21
22	strategy:
23	matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
24
25	steps:
26	- uses: actions/checkout@v2
27	- uses: ljharb/actions/node/run@main
28	name: 'npm install && npm run tests-only'
29	with:
30	node-version: ${{ matrix.node-version }}
31	command: 'tests-only'
32	minors:
33	needs: [matrix, latest]
34	name: 'non-latest minors'
35	continue-on-error: true
36	if: ${{ !github.head_ref \|\| !startsWith(github.head_ref, 'renovate') }}
37	runs-on: ubuntu-latest
38
39	strategy:
40	matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
41
42	steps:
43	- uses: actions/checkout@v2
44	- uses: ljharb/actions/node/run@main
45	with:
46	node-version: ${{ matrix.node-version }}
47	command: 'tests-only'
48
49	node:
50	name: 'node 4+'
51	needs: [latest, minors]
52	runs-on: ubuntu-latest
53	steps:
54	- run: 'echo tests completed'

node_modules/is-core-module/.github/workflows/node-iojs.yml+0−58

@@ -1,58 +0,0 @@
1	name: 'Tests: node.js (io.js)'
2
3	on: [pull_request, push]
4
5	jobs:
6	matrix:
7	runs-on: ubuntu-latest
8	outputs:
9	latest: ${{ steps.set-matrix.outputs.requireds }}
10	minors: ${{ steps.set-matrix.outputs.optionals }}
11	steps:
12	- uses: ljharb/actions/node/matrix@main
13	id: set-matrix
14	with:
15	preset: 'iojs'
16
17	latest:
18	needs: [matrix]
19	name: 'latest minors'
20	runs-on: ubuntu-latest
21
22	strategy:
23	matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
24
25	steps:
26	- uses: actions/checkout@v2
27	- uses: ljharb/actions/node/run@main
28	name: 'npm install && npm run tests-only'
29	with:
30	node-version: ${{ matrix.node-version }}
31	command: 'tests-only'
32	skip-ls-check: true
33
34	minors:
35	needs: [matrix, latest]
36	name: 'non-latest minors'
37	continue-on-error: true
38	if: ${{ !github.head_ref \|\| !startsWith(github.head_ref, 'renovate') }}
39	runs-on: ubuntu-latest
40
41	strategy:
42	matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
43
44	steps:
45	- uses: actions/checkout@v2
46	- uses: ljharb/actions/node/run@main
47	name: 'npm install && npm run tests-only'
48	with:
49	node-version: ${{ matrix.node-version }}
50	command: 'tests-only'
51	skip-ls-check: true
52
53	node:
54	name: 'io.js'
55	needs: [latest, minors]
56	runs-on: ubuntu-latest
57	steps:
58	- run: 'echo tests completed'

node_modules/is-core-module/.github/workflows/node-pretest.yml+0−26

@@ -1,26 +0,0 @@
1	name: 'Tests: pretest/posttest'
2
3	on: [pull_request, push]
4
5	jobs:
6	pretest:
7	runs-on: ubuntu-latest
8
9	steps:
10	- uses: actions/checkout@v2
11	- uses: ljharb/actions/node/run@main
12	name: 'npm install && npm run pretest'
13	with:
14	node-version: 'lts/*'
15	command: 'pretest'
16
17	posttest:
18	runs-on: ubuntu-latest
19
20	steps:
21	- uses: actions/checkout@v2
22	- uses: ljharb/actions/node/run@main
23	name: 'npm install && npm run posttest'
24	with:
25	node-version: 'lts/*'
26	command: 'posttest'

node_modules/is-core-module/.github/workflows/node-zero.yml+0−58

@@ -1,58 +0,0 @@
1	name: 'Tests: node.js (0.x)'
2
3	on: [pull_request, push]
4
5	jobs:
6	matrix:
7	runs-on: ubuntu-latest
8	outputs:
9	stable: ${{ steps.set-matrix.outputs.requireds }}
10	unstable: ${{ steps.set-matrix.outputs.optionals }}
11	steps:
12	- uses: ljharb/actions/node/matrix@main
13	id: set-matrix
14	with:
15	preset: '0.x'
16
17	stable:
18	needs: [matrix]
19	name: 'stable minors'
20	runs-on: ubuntu-latest
21
22	strategy:
23	matrix: ${{ fromJson(needs.matrix.outputs.stable) }}
24
25	steps:
26	- uses: actions/checkout@v2
27	- uses: ljharb/actions/node/run@main
28	with:
29	node-version: ${{ matrix.node-version }}
30	command: 'tests-only'
31	cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id }}
32	skip-ls-check: true
33
34	unstable:
35	needs: [matrix, stable]
36	name: 'unstable minors'
37	continue-on-error: true
38	if: ${{ !github.head_ref \|\| !startsWith(github.head_ref, 'renovate') }}
39	runs-on: ubuntu-latest
40
41	strategy:
42	matrix: ${{ fromJson(needs.matrix.outputs.unstable) }}
43
44	steps:
45	- uses: actions/checkout@v2
46	- uses: ljharb/actions/node/run@main
47	with:
48	node-version: ${{ matrix.node-version }}
49	command: 'tests-only'
50	cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id }}
51	skip-ls-check: true
52
53	node:
54	name: 'node 0.x'
55	needs: [stable, unstable]
56	runs-on: ubuntu-latest
57	steps:
58	- run: 'echo tests completed'

node_modules/is-core-module/.github/workflows/rebase.yml+0−15

@@ -1,15 +0,0 @@
1	name: Automatic Rebase
2
3	on: [pull_request_target]
4
5	jobs:
6	_:
7	name: "Automatic Rebase"
8
9	runs-on: ubuntu-latest
10
11	steps:
12	- uses: actions/checkout@v1
13	- uses: ljharb/rebase@master
14	env:
15	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

node_modules/is-core-module/.github/workflows/require-allow-edits.yml+0−14

@@ -1,14 +0,0 @@
1	name: Require “Allow Edits”
2
3	on: [pull_request_target]
4
5	jobs:
6	_:
7	name: "Require “Allow Edits”"
8
9	runs-on: ubuntu-latest
10
11	steps:
12	- uses: ljharb/require-allow-edits@main
13	env:
14	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

node_modules/resolve/.github/workflows/node-4+.yml+0−54

@@ -1,54 +0,0 @@
1	name: 'Tests: node.js'
2
3	on: [pull_request, push]
4
5	jobs:
6	matrix:
7	runs-on: ubuntu-latest
8	outputs:
9	latest: ${{ steps.set-matrix.outputs.requireds }}
10	minors: ${{ steps.set-matrix.outputs.optionals }}
11	steps:
12	- uses: ljharb/actions/node/matrix@main
13	id: set-matrix
14	with:
15	preset: '>=4'
16
17	latest:
18	needs: [matrix]
19	name: 'latest minors'
20	runs-on: ubuntu-latest
21
22	strategy:
23	matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
24
25	steps:
26	- uses: actions/checkout@v2
27	- uses: ljharb/actions/node/run@main
28	name: 'npm install && npm run tests-only'
29	with:
30	node-version: ${{ matrix.node-version }}
31	command: 'tests-only'
32	minors:
33	needs: [matrix, latest]
34	name: 'non-latest minors'
35	continue-on-error: true
36	if: ${{ !github.head_ref \|\| !startsWith(github.head_ref, 'renovate') }}
37	runs-on: ubuntu-latest
38
39	strategy:
40	matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
41
42	steps:
43	- uses: actions/checkout@v2
44	- uses: ljharb/actions/node/run@main
45	with:
46	node-version: ${{ matrix.node-version }}
47	command: 'tests-only'
48
49	node:
50	name: 'node 4+'
51	needs: [latest, minors]
52	runs-on: ubuntu-latest
53	steps:
54	- run: 'echo tests completed'

node_modules/resolve/.github/workflows/node-iojs.yml+0−55

@@ -1,55 +0,0 @@
1	name: 'Tests: node.js (io.js)'
2
3	on: [pull_request, push]
4
5	jobs:
6	matrix:
7	runs-on: ubuntu-latest
8	outputs:
9	latest: ${{ steps.set-matrix.outputs.requireds }}
10	minors: ${{ steps.set-matrix.outputs.optionals }}
11	steps:
12	- uses: ljharb/actions/node/matrix@main
13	id: set-matrix
14	with:
15	preset: 'iojs'
16
17	latest:
18	needs: [matrix]
19	name: 'latest minors'
20	runs-on: ubuntu-latest
21
22	strategy:
23	matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
24
25	steps:
26	- uses: actions/checkout@v2
27	- uses: ljharb/actions/node/run@main
28	name: 'npm install && npm run tests-only'
29	with:
30	node-version: ${{ matrix.node-version }}
31	command: 'tests-only'
32	minors:
33	needs: [matrix, latest]
34	name: 'non-latest minors'
35	continue-on-error: true
36	if: ${{ !github.head_ref \|\| !startsWith(github.head_ref, 'renovate') }}
37	runs-on: ubuntu-latest
38
39	strategy:
40	matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
41
42	steps:
43	- uses: actions/checkout@v2
44	- uses: ljharb/actions/node/run@main
45	name: 'npm install && npm run tests-only'
46	with:
47	node-version: ${{ matrix.node-version }}
48	command: 'tests-only'
49
50	node:
51	name: 'io.js'
52	needs: [latest, minors]
53	runs-on: ubuntu-latest
54	steps:
55	- run: 'echo tests completed'

node_modules/resolve/.github/workflows/node-pretest.yml+0−27

@@ -1,27 +0,0 @@
1	name: 'Tests: pretest/posttest'
2
3	on: [pull_request, push]
4
5	jobs:
6	pretest:
7	runs-on: ubuntu-latest
8
9
10	steps:
11	- uses: actions/checkout@v2
12	- uses: ljharb/actions/node/run@main
13	name: 'npm install && npm run pretest'
14	with:
15	node-version: 'lts/*'
16	command: 'pretest'
17
18	posttest:
19	runs-on: ubuntu-latest
20
21	steps:
22	- uses: actions/checkout@v2
23	- uses: ljharb/actions/node/run@main
24	name: 'npm install && npm run posttest'
25	with:
26	node-version: 'lts/*'
27	command: 'posttest'

node_modules/resolve/.github/workflows/node-zero.yml+0−55

@@ -1,55 +0,0 @@
1	name: 'Tests: node.js (0.x)'
2
3	on: [pull_request, push]
4
5	jobs:
6	matrix:
7	runs-on: ubuntu-latest
8	outputs:
9	stable: ${{ steps.set-matrix.outputs.requireds }}
10	unstable: ${{ steps.set-matrix.outputs.optionals }}
11	steps:
12	- uses: ljharb/actions/node/matrix@main
13	id: set-matrix
14	with:
15	preset: '0.x'
16
17	stable:
18	needs: [matrix]
19	name: 'stable minors'
20	runs-on: ubuntu-latest
21
22	strategy:
23	matrix: ${{ fromJson(needs.matrix.outputs.stable) }}
24
25	steps:
26	- uses: actions/checkout@v2
27	- uses: ljharb/actions/node/run@main
28	with:
29	node-version: ${{ matrix.node-version }}
30	command: 'tests-only'
31	cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id }}
32	unstable:
33	needs: [matrix, stable]
34	name: 'unstable minors'
35	continue-on-error: true
36	if: ${{ !github.head_ref \|\| !startsWith(github.head_ref, 'renovate') }}
37	runs-on: ubuntu-latest
38
39	strategy:
40	matrix: ${{ fromJson(needs.matrix.outputs.unstable) }}
41
42	steps:
43	- uses: actions/checkout@v2
44	- uses: ljharb/actions/node/run@main
45	with:
46	node-version: ${{ matrix.node-version }}
47	command: 'tests-only'
48	cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id }}
49
50	node:
51	name: 'node 0.x'
52	needs: [stable, unstable]
53	runs-on: ubuntu-latest
54	steps:
55	- run: 'echo tests completed'

node_modules/resolve/.github/workflows/rebase.yml+0−15

@@ -1,15 +0,0 @@
1	name: Automatic Rebase
2
3	on: [pull_request_target]
4
5	jobs:
6	_:
7	name: "Automatic Rebase"
8
9	runs-on: ubuntu-latest
10
11	steps:
12	- uses: actions/checkout@v2
13	- uses: ljharb/rebase@master
14	env:
15	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

node_modules/resolve/.github/workflows/require-allow-edits.yml+0−14

@@ -1,14 +0,0 @@
1	name: Require “Allow Edits”
2
3	on: [pull_request_target]
4
5	jobs:
6	_:
7	name: "Require “Allow Edits”"
8
9	runs-on: ubuntu-latest
10
11	steps:
12	- uses: ljharb/require-allow-edits@main
13	env:
14	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

node_modules/resolve/test/resolver/symlinked/_/symlink_target/.gitkeep+0−0

Empty file deleted.

node_modules/simple-git/LICENSE+0−20

@@ -1,20 +0,0 @@
1	The MIT License (MIT)
2
3	Copyright (c) 2015 Steve King
4
5	Permission is hereby granted, free of charge, to any person obtaining a copy of
6	this software and associated documentation files (the "Software"), to deal in
7	the Software without restriction, including without limitation the rights to
8	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9	the Software, and to permit persons to whom the Software is furnished to do so,
10	subject to the following conditions:
11
12	The above copyright notice and this permission notice shall be included in all
13	copies or substantial portions of the Software.
14
15	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17	FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18	COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19	IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/simple-git/package.json+0−74

@@ -1,74 +0,0 @@
1	{
2	"_from": "simple-git@^1.70.0",
3	"_id": "simple-git@1.132.0",
4	"_inBundle": false,
5	"_integrity": "sha512-xauHm1YqCTom1sC9eOjfq3/9RKiUA9iPnxBbrY2DdL8l4ADMu0jjM5l5lphQP5YWNqAL2aXC/OeuQ76vHtW5fg==",
6	"_location": "/simple-git",
7	"_phantomChildren": {},
8	"_requested": {
9	"type": "range",
10	"registry": true,
11	"raw": "simple-git@^1.70.0",
12	"name": "simple-git",
13	"escapedName": "simple-git",
14	"rawSpec": "^1.70.0",
15	"saveSpec": null,
16	"fetchSpec": "^1.70.0"
17	},
18	"_requiredBy": [
19	"/bulk-decaffeinate"
20	],
21	"_resolved": "https://registry.npmjs.org/simple-git/-/simple-git-1.132.0.tgz",
22	"_shasum": "53ac4c5ec9e74e37c2fd461e23309f22fcdf09b1",
23	"_spec": "simple-git@^1.70.0",
24	"_where": "/home/simon/src/devdocs/node_modules/bulk-decaffeinate",
25	"author": {
26	"name": "Steve King",
27	"email": "steve@mydev.co"
28	},
29	"bugs": {
30	"url": "https://github.com/steveukx/git-js/issues"
31	},
32	"bundleDependencies": false,
33	"contributors": [
34	{
35	"name": "Steve King",
36	"email": "steve@mydev.co"
37	}
38	],
39	"dependencies": {
40	"debug": "^4.0.1"
41	},
42	"deprecated": false,
43	"description": "Simple GIT interface for node.js",
44	"devDependencies": {
45	"@kwsites/test-runner": "^0.1.1",
46	"sinon": "^7.3.2"
47	},
48	"files": [
49	"promise.*",
50	"src/",
51	"typings/"
52	],
53	"homepage": "https://github.com/steveukx/git-js#readme",
54	"keywords": [
55	"git",
56	"source control",
57	"vcs"
58	],
59	"license": "MIT",
60	"main": "./src/index.js",
61	"name": "simple-git",
62	"repository": {
63	"type": "git",
64	"url": "git://github.com/steveukx/git-js.git"
65	},
66	"scripts": {
67	"postversion": "npm publish && git push && git push --tags",
68	"preversion": "yarn test",
69	"test": "runner test/*/test.js ",
70	"test:integration": "runner test/integration/test*.js",
71	"test:unit": "runner test/unit/test*.js"
72	},
73	"version": "1.132.0"
74	}

node_modules/simple-git/promise.d.ts+0−576

@@ -1,576 +0,0 @@
1	import * as resp from "./typings/response";
2
3	declare function simplegit(basePath?: string): simplegit.SimpleGit;
4
5	declare namespace simplegit {
6
7	interface SimpleGit {
8	/**
9	* Adds one or more files to source control
10	*
11	* @param {string\|string[]} files
12	* @returns {Promise<void>}
13	*/
14	add(files: string \| string[]): Promise<void>;
15
16	/**
17	* Add an annotated tag to the head of the current branch
18	*
19	* @param {string} tagName
20	* @param {string} tagMessage
21	* @returns {Promise<void>}
22	*/
23	addAnnotatedTag(tagName: string, tagMessage: string): Promise<void>;
24
25	/**
26	* Add config to local git instance
27	*
28	* @param {string} key configuration key (e.g user.name)
29	* @param {string} value for the given key (e.g your name)
30	* @returns {Promise<string>}
31	*/
32	addConfig(key: string, value: string): Promise<string>;
33
34	/**
35	* Adds a remote to the list of remotes.
36	*
37	* @param {string} remoteName Name of the repository - eg "upstream"
38	* @param {string} remoteRepo Fully qualified SSH or HTTP(S) path to the remote repo
39	* @returns {Promise<void>}
40	*/
41	addRemote(remoteName: string, remoteRepo: string): Promise<void>;
42
43	/**
44	* Add a lightweight tag to the head of the current branch
45	*
46	* @param {string} name
47	* @returns {Promise<string>}
48	*/
49	addTag(name: string): Promise<string>;
50
51	/**
52	* Equivalent to `catFile` but will return the native `Buffer` of content from the git command's stdout.
53	*
54	* @param {string[]} options
55	*/
56	binaryCatFile(options: string[]): Promise<any>;
57
58	/**
59	* List all branches
60	*/
61	branch(): Promise<BranchSummary>;
62	branch(options: Options \| string[]): Promise<BranchSummary>;
63
64	/**
65	* List of local branches
66	*
67	* @returns {Promise<BranchSummary>}
68	*/
69	branchLocal(): Promise<BranchSummary>;
70
71	/**
72	* Returns a list of objects in a tree based on commit hash.
73	* Passing in an object hash returns the object's content, size, and type.
74	*
75	* Passing "-p" will instruct cat-file to determine the object type, and display its formatted contents.
76	*
77	* @param {string[]} [options]
78	* @returns {Promise<string>}
79	*
80	* @see https://git-scm.com/docs/git-cat-file
81	*/
82	catFile(options: string[]): Promise<string>;
83
84	/**
85	* Check if a pathname or pathnames are excluded by .gitignore
86	*
87	* @param {string\|string[]} pathnames
88	*/
89	checkIgnore(pathnames: string[]): Promise<string[]>;
90
91	checkIgnore(path: string): Promise<string[]>;
92
93	/**
94	* Validates that the current repo is a Git repo.
95	*
96	* @returns {Promise<boolean>}
97	*/
98	checkIsRepo(): Promise<boolean>;
99
100	/**
101	* Checkout a tag or revision, any number of additional arguments can be passed to the `git* checkout` command
102	by supplying either a string or array of strings as the `what` parameter.
103	*
104	* @param {(string \| string[])} what one or more commands to pass to `git checkout`.
105	* @returns {Promise<void>}
106	*/
107	checkout(what: string \| string[]): Promise<void>;
108
109	/**
110	* Checkout a remote branch.
111	*
112	* @param {string} branchName name of branch.
113	* @param {string} startPoint (e.g origin/development).
114	* @returns {Promise<void>}
115	*/
116	checkoutBranch(branchName: string, startPoint: string): Promise<void>;
117
118	/**
119	* Internally uses pull and tags to get the list of tags then checks out the latest tag.
120	*/
121	checkoutLatestTag(branchName: string, startPoint: string): Promise<void>;
122
123	/**
124	* Checkout a local branch
125	*
126	* @param {string} branchName name of branch.
127	* @returns {Promise<void>}
128	*/
129	checkoutLocalBranch(branchName: string): Promise<void>;
130
131	/**
132	* @param {string} mode Required parameter "n" or "f"
133	* @param {string[]} options
134	*/
135	clean(
136	mode: 'd' \| 'f' \| 'i' \| 'n' \| 'q' \| 'x' \| 'X',
137	options?: string[]
138	): Promise<string>;
139
140	/**
141	* Clears the queue of pending commands and returns the wrapper instance for chaining.
142	*/
143	clearQueue(): this;
144
145	/**
146	* Clone a repository into a new directory.
147	*
148	* @param {string} repoPath repository url to clone e.g. https://github.com/steveukx/git-js.git
149	* @param {string} localPath local folder path to clone to.
150	* @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-clone).
151	* @returns {Promise<void>}
152	*/
153	clone(repoPath: string, localPath: string, options?: Options \| string[]): Promise<string>;
154	clone(repoPath: string, options?: Options \| string[]): Promise<string>;
155
156	/**
157	* Commits changes in the current working directory - when specific file paths are supplied, only changes on those
158	* files will be committed.
159	*
160	* @param {string\|string[]} message
161	* @param {string\|string[]} [files]
162	* @param {Object} [options]
163	*/
164	commit(
165	message: string \| string[],
166	files?: string \| string[],
167	options?: Options
168	): Promise<resp.CommitSummary>;
169
170	/**
171	* Sets the path to a custom git binary, should either be `git` when there is an installation of git available on
172	* the system path, or a fully qualified path to the executable.
173	*
174	* @param {string} command
175	*/
176	customBinary(command: string): this;
177
178	/**
179	* Sets the working directory of the subsequent commands.
180	*
181	* @param {string} workingDirectory
182	*/
183	cwd<path extends string>(workingDirectory: path): Promise<path>;
184
185	/**
186	* Delete a local branch
187	*
188	* @param {string} branchName name of branch
189	*/
190	deleteLocalBranch(branchName: string):
191	Promise<resp.BranchDeletionSummary>;
192
193	/**
194	* Get the diff of the current repo compared to the last commit with a set of options supplied as a string.
195	*
196	* @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-diff).
197	* @returns {Promise<string>} raw string result.
198	*/
199	diff(options?: string[]): Promise<string>;
200
201	/**
202	* Gets a summary of the diff for files in the repo, uses the `git diff --stat` format to calculate changes.
203	*
204	* in order to get staged (only): `--cached` or `--staged`.
205	*
206	* @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-diff).
207	* @returns {Promise<DiffResult>} Parsed diff summary result.
208	*/
209	diffSummary(options?: string[]): Promise<DiffResult>;
210
211	/**
212	* Sets an environment variable for the spawned child process, either supply both a name and value as strings or
213	* a single object to entirely replace the current environment variables.
214	*
215	* @param {string\|Object} name
216	* @param {string} [value]
217	*/
218	env(name: string, value: string): this;
219
220	env(env: object): this;
221
222	/**
223	* Updates the local working copy database with changes from the default remote repo and branch.
224	*
225	* @param {string \| string[]} [remote] remote to fetch from.
226	* @param {string} [branch] branch to fetch from.
227	* @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-fetch).
228	* @returns {Promise<FetchResult>} Parsed fetch result.
229	*/
230	fetch(remote?: string \| string[], branch?: string, options?: Options): Promise<FetchResult>;
231
232	/**
233	* Gets the currently available remotes, setting the optional verbose argument to true includes additional
234	* detail on the remotes themselves.
235	*
236	* @param {boolean} [verbose=false]
237	*/
238	getRemotes(verbose: false \| undefined): Promise<resp.RemoteWithoutRefs[]>;
239
240	getRemotes(verbose: true): Promise<resp.RemoteWithRefs[]>;
241
242	/**
243	* Initialize a git repo
244	*
245	* @param {Boolean} [bare=false]
246	*/
247	init(bare?: boolean): Promise<void>;
248
249	/**
250	* List remote
251	*
252	* @param {string[]} [args]
253	*/
254	listRemote(args: string[]): Promise<string>;
255
256	/**
257	* Show commit logs from `HEAD` to the first commit.
258	* If provided between `options.from` and `options.to` tags or branch.
259	*
260	* You can provide `options.file`, which is the path to a file in your repository. Then only this file will be considered.
261	*
262	* To use a custom splitter in the log format, set `options.splitter` to be the string the log should be split on.
263	*
264	* By default the following fields will be part of the result:
265	* `hash`: full commit hash
266	* `date`: author date, ISO 8601-like format
267	* `message`: subject + ref names, like the --decorate option of git-log
268	* `author_name`: author name
269	* `author_email`: author mail
270	* You can specify `options.format` to be an mapping from key to a format option like `%H` (for commit hash).
271	* The fields specified in `options.format` will be the fields in the result.
272	*
273	* Options can also be supplied as a standard options object for adding custom properties supported by the git log command.
274	* For any other set of options, supply options as an array of strings to be appended to the git log command.
275	*
276	* @param {LogOptions} [options]
277	*
278	* @returns Promise<ListLogSummary>
279	*
280	* @see https://git-scm.com/docs/git-log
281	*/
282	log<T = resp.DefaultLogFields>(options?: LogOptions<T>): Promise<resp.ListLogSummary<T>>;
283
284	/**
285	* Runs a merge, `options` can be either an array of arguments
286	* supported by the [`git merge`](https://git-scm.com/docs/git-merge)
287	* or an options object.
288	*
289	* Conflicts during the merge result in an error response,
290	* the response type whether it was an error or success will be a MergeSummary instance.
291	* When successful, the MergeSummary has all detail from a the PullSummary
292	*
293	* @param {Options \| string[]} [options] options supported by [git](https://git-scm.com/docs/git-merge).
294	* @returns {Promise<any>}
295	*
296	* @see https://github.com/steveukx/git-js/blob/master/src/responses/MergeSummary.js
297	* @see https://github.com/steveukx/git-js/blob/master/src/responses/PullSummary.js
298	*/
299	merge(options: Options \| string[]): Promise<MergeSummary>;
300
301	/**
302	* Merges from one branch to another, equivalent to running `git merge ${from} $[to}`, the `options` argument can
303	* either be an array of additional parameters to pass to the command or null / omitted to be ignored.
304	*
305	* @param {string} from branch to merge from.
306	* @param {string} to branch to merge to.
307	* @param {string[]} [options] options supported by [git](https://git-scm.com/docs/git-merge).
308	* @returns {Promise<string>}
309	*/
310	mergeFromTo(from: string, to: string, options?: string[]): Promise<string>;
311
312	/**
313	* Mirror a git repo
314	*
315	* @param {string} repoPath
316	* @param {string} localPath
317	*/
318	mirror(repoPath: string, localPath: string): Promise<string>;
319
320	/**
321	* Moves one or more files to a new destination.
322	*
323	* @see https://git-scm.com/docs/git-mv
324	*
325	* @param {string\|string[]} from
326	* @param {string} to
327	*/
328	mv(from: string \| string[], to: string): Promise<resp.MoveSummary>;
329
330	/**
331	* Sets a handler function to be called whenever a new child process is created, the handler function will be called
332	* with the name of the command being run and the stdout & stderr streams used by the ChildProcess.
333	*
334	* @example
335	* require('simple-git')
336	* .outputHandler(function (command, stdout, stderr) {
337	* stdout.pipe(process.stdout);
338	* })
339	* .checkout('https://github.com/user/repo.git');
340	*
341	* @see https://nodejs.org/api/child_process.html#child_process_class_childprocess
342	* @see https://nodejs.org/api/stream.html#stream_class_stream_readable
343	* @param {Function} outputHandler
344	*/
345	outputHandler(handler: outputHandler \| void): this;
346
347	/**
348	* Fetch from and integrate with another repository or a local branch.
349	*
350	* @param {string} [remote] remote to pull from.
351	* @param {string} [branch] branch to pull from.
352	* @param {Options} [options] options supported by [git](https://git-scm.com/docs/git-pull).
353	* @returns {Promise<PullResult>} Parsed pull result.
354	*/
355	pull(remote?: string, branch?: string, options?: Options): Promise<PullResult>;
356
357	/**
358	* Update remote refs along with associated objects.
359	*
360	* @param {string} [remote] remote to push to.
361	* @param {string} [branch] branch to push to.
362	* @param {Options} [options] options supported by [git](https://git-scm.com/docs/git-push).
363	* @returns {Promise<void>}
364	*/
365	push(remote?: string, branch?: string, options?: Options): Promise<void>;
366
367	/**
368	* Pushes the current tag changes to a remote which can be either a URL or named remote. When not specified uses the
369	* default configured remote spec.
370	*
371	* @param {string} [remote]
372	*/
373	pushTags(remote?: string): Promise<string>;
374
375	/**
376	* Executes any command against the git binary.
377	*
378	* @param {string[]\|Object} commands
379	*/
380	raw(commands: string \| string[]): Promise<string>;
381
382	/**
383	* Rebases the current working copy. Options can be supplied either as an array of string parameters
384	* to be sent to the `git rebase` command, or a standard options object.
385	*
386	* @param {Object\|String[]} [options]
387	*/
388	rebase(options?: Options \| string[]): Promise<string>;
389
390	/**
391	* Call any `git remote` function with arguments passed as an array of strings.
392	*
393	* @param {string[]} options
394	*/
395	remote(options: string[]): Promise<void \| string>;
396
397	/**
398	* Removes an entry from the list of remotes.
399	*
400	* @param {string} remoteName Name of the repository - eg "upstream"
401	* @returns {*}
402	*/
403	removeRemote(remote: string): Promise<void>;
404
405	/**
406	* Reset a repo
407	*
408	* @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.
409	*/
410	reset(mode?: 'soft' \| 'mixed' \| 'hard' \| 'merge' \| 'keep'): Promise<null>;
411
412	reset(commands?: string[]): Promise<void>;
413
414	/**
415	* Revert one or more commits in the local working copy
416	*
417	* @param {string} commit The commit to revert. Can be any hash, offset (eg: `HEAD~2`) or range (eg: `master~5..master~2`)
418	* @param {Object} [options] Optional options object
419	*/
420	revert(commit: String, options?: Options): Promise<void>;
421
422	/**
423	* Wraps `git rev-parse`. Primarily used to convert friendly commit references (ie branch names) to SHA1 hashes.
424	*
425	* Options should be an array of string options compatible with the `git rev-parse`
426	*
427	* @param {string[]} [options]
428	*
429	* @returns Promise<string>
430	*
431	* @see https://git-scm.com/docs/git-rev-parse
432	*/
433	revparse(options?: string[]): Promise<string>;
434
435	/**
436	* Removes the named files from source control.
437	*
438	* @param {string\|string[]} files
439	*/
440	rm(paths: string \| string[]): Promise<void>;
441
442	/**
443	* Removes the named files from source control but keeps them on disk rather than deleting them entirely. To
444	* completely remove the files, use `rm`.
445	*
446	* @param {string\|string[]} files
447	*/
448	rmKeepLocal(paths: string \| string[]): Promise<void>;
449
450	/**
451	* Show various types of objects, for example the file at a certain commit
452	*
453	* @param {string[]} [options]
454	*/
455	show(options?: string[]): Promise<string>;
456
457	/**
458	* Disables/enables the use of the console for printing warnings and errors, by default messages are not shown in
459	* a production environment.
460	*
461	* @param {boolean} silence
462	* @returns {simplegit.SimpleGit}
463	*/
464	silent(silence?: boolean): simplegit.SimpleGit;
465
466	/**
467	* Stash the local repo
468	*
469	* @param {Object\|Array} [options]
470	*/
471	stash(options?: Options \| any[]): Promise<string>;
472
473	/**
474	* List the stash(s) of the local repo
475	*
476	* @param {Object\|Array} [options]
477	*/
478	stashList(options?: Options \| string[]): Promise<resp.ListLogSummary>;
479
480	/**
481	* Show the working tree status.
482	*
483	* @returns {Promise<StatusResult>} Parsed status result.
484	*/
485	status(): Promise<StatusResult>;
486
487	/**
488	* Call any `git submodule` function with arguments passed as an array of strings.
489	*
490	* @param {string[]} options
491	*/
492	subModule(options: string[]): Promise<string>;
493
494	/**
495	* Add a submodule
496	*
497	* @param {string} repo
498	* @param {string} path
499	*/
500	submoduleAdd(repo: string, path: string): Promise<void>;
501
502	/**
503	* Initialize submodules
504	*
505	* @param {string[]} [args]
506	*/
507	submoduleInit(options?: string[]): Promise<string>;
508
509	/**
510	* Update submodules
511	*
512	* @param {string[]} [args]
513	*/
514	submoduleUpdate(options?: string[]): Promise<string>;
515
516	/**
517	* List all tags. When using git 2.7.0 or above, include an options object with `"--sort": "property-name"` to
518	* sort the tags by that property instead of using the default semantic versioning sort.
519	*
520	* Note, supplying this option when it is not supported by your Git version will cause the operation to fail.
521	*
522	* @param {Object} [options]
523	*/
524	tag(options?: Options \| string[]): Promise<string>;
525
526	/**
527	* Gets a list of tagged versions.
528	*
529	* @param {Options} options
530	* @returns {Promise<TagResult>} Parsed tag list.
531	*/
532	tags(options?: Options): Promise<TagResult>;
533
534	/**
535	* Updates repository server info
536	*/
537	updateServerInfo(): Promise<string>;
538	}
539
540	type Options = { [key: string]: null \| string \| any };
541
542	type LogOptions<T = resp.DefaultLogFields> = Options & {
543	format?: T;
544	file?: string;
545	from?: string;
546	multiLine?: boolean;
547	symmetric?: boolean;
548	to?: string;
549	};
550
551	// responses
552	// ---------------------
553	interface BranchSummary extends resp.BranchSummary {}
554
555	interface CommitSummary extends resp.CommitSummary {}
556
557	interface MergeSummary extends resp.MergeSummary {}
558
559	interface PullResult extends resp.PullResult {}
560
561	interface FetchResult extends resp.FetchResult {}
562
563	interface StatusResult extends resp.StatusResult {}
564
565	interface DiffResult extends resp.DiffResult {}
566
567	interface TagResult extends resp.TagResult {}
568
569	type outputHandler = (
570	command: string,
571	stdout: NodeJS.ReadableStream,
572	stderr: NodeJS.ReadableStream
573	) => void
574	}
575
576	export = simplegit;

node_modules/simple-git/promise.js+0−96

@@ -1,96 +0,0 @@
1
2	if (typeof Promise === 'undefined') {
3	throw new ReferenceError("Promise wrappers must be enabled to use the promise API");
4	}
5
6	function isAsyncCall (fn) {
7	return /^[^)]+then\s*\)/.test(fn) \|\| /\._run\(/.test(fn);
8	}
9
10	module.exports = function (baseDir) {
11
12	var Git = require('./src/git');
13	var gitFactory = require('./src');
14	var git;
15
16
17	var chain = Promise.resolve();
18
19	try {
20	git = gitFactory(baseDir);
21	}
22	catch (e) {
23	chain = Promise.reject(e);
24	}
25
26	return Object.keys(Git.prototype).reduce(function (promiseApi, fn) {
27	if (/^_\|then/.test(fn)) {
28	return promiseApi;
29	}
30
31	if (isAsyncCall(Git.prototype[fn])) {
32	promiseApi[fn] = git ? asyncWrapper(fn, git) : function () {
33	return chain;
34	};
35	}
36
37	else {
38	promiseApi[fn] = git ? syncWrapper(fn, git, promiseApi) : function () {
39	return promiseApi;
40	};
41	}
42
43	return promiseApi;
44
45	}, {});
46
47	function asyncWrapper (fn, git) {
48	return function () {
49	var args = [].slice.call(arguments);
50
51	if (typeof args[args.length] === 'function') {
52	throw new TypeError(
53	"Promise interface requires that handlers are not supplied inline, " +
54	"trailing function not allowed in call to " + fn);
55	}
56
57	return chain.then(function () {
58	return new Promise(function (resolve, reject) {
59	args.push(function (err, result) {
60	if (err) {
61	return reject(toError(err));
62	}
63
64	resolve(result);
65	});
66
67	git[fn].apply(git, args);
68	});
69	});
70	};
71	}
72
73	function syncWrapper (fn, git, api) {
74	return function () {
75	git[fn].apply(git, arguments);
76
77	return api;
78	};
79	}
80
81	};
82
83	function toError (error) {
84
85	if (error instanceof Error) {
86	return error;
87	}
88
89	if (typeof error === 'string') {
90	return new Error(error);
91	}
92
93	return Object.create(new Error(error), {
94	git: { value: error },
95	});
96	}

node_modules/simple-git/readme.md+0−380

@@ -1,380 +0,0 @@
1	# Simple Git
2	[![NPM version](https://img.shields.io/npm/v/simple-git.svg)](https://www.npmjs.com/package/simple-git) [![Build Status](https://travis-ci.org/steveukx/git-js.svg?branch=master)](https://travis-ci.org/steveukx/git-js)
3
4	A light weight interface for running git commands in any [node.js](https://nodejs.org) application.
5
6	# Installation
7
8	Easiest through [npm](https://npmjs.org): `npm install simple-git`
9
10	# Dependencies
11
12	Requires [git](https://git-scm.com/downloads) to be installed and that it can be called using the command `git`.
13
14	# Usage
15
16	Include into your app using:
17
18	```js
19	const simpleGit = require('simple-git')(workingDirPath);
20	```
21
22	> where the `workingDirPath` is optional, defaulting to the current directory.
23
24	Use `simpleGit` by chaining any of its functions together. Each function accepts an optional final argument which will
25	be called when that step has been completed. When it is called it has two arguments - firstly an error object (or null
26	when no error occurred) and secondly the data generated by that call.
27
28	\| API \| What it does \|
29	\|-----\|--------------\|
30	\| `.add([fileA, ...], handlerFn)` \| adds one or more files to be under source control \|
31	\| `.addAnnotatedTag(tagName, tagMessage, handlerFn)` \| adds an annotated tag to the head of the current branch \|
32	\| `.addConfig(key, value[, handlerFn])` \| add a local configuration property \|
33	\| `.addRemote(name, repo, handlerFn)` \| adds a new named remote to be tracked as `name` at the path `repo` \|
34	\| `.addTag(name, handlerFn)` \| adds a lightweight tag to the head of the current branch \|
35	\| `.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. \|
36	\| `.branchLocal([handlerFn])` \| gets a list of local branches, calls `handlerFn` with two arguments, an error object and [BranchSummary](src/responses/BranchSummary.js) instance \|
37	\| `.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 \|
38	\| `.checkIgnore([filepath, ...], handlerFn)` \| checks if filepath excluded by .gitignore rules \|
39	\| `.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. \|
40	\| `.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. \|
41	\| `.checkoutBranch(branchName, startPoint, handlerFn)` \| checks out a new branch from the supplied start point \|
42	\| `.checkoutLatestTag(handlerFn)` \| convenience method to pull then checkout the latest tag \|
43	\| `.checkoutLocalBranch(branchName, handlerFn)` \| checks out a new local branch \|
44	\| `.clean(mode [, options [, handlerFn]])` \| clean the working tree. Mode should be "n" - dry run or "f" - force \|
45	\| `.clearQueue()` \| immediately clears the queue of pending tasks (note: any command currently in progress will still call its completion callback) \|
46	\| `.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 \|
47	\| `.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) \|
48	\| `.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 \|
49	\| `.customBinary(gitPath)` \| sets the command to use to reference git, allows for using a git binary not available on the path environment variable \|
50	\| `.cwd(workingDirectory)` \| Sets the current working directory for all commands after this step in the chain \|
51	\| `.deleteLocalBranch(branchName, handlerFn)` \| deletes a local branch \|
52	\| `.diff(options, handlerFn)` \| get the diff of the current repo compared to the last commit with a set of options supplied as a string \|
53	\| `.diff(handlerFn)` \| get the diff for all file in the current repo compared to the last commit \|
54	\| `.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) \|
55	\| `.diffSummary(options, handlerFn)` \| includes options in the call to `diff --stat options` and returns a [DiffSummary](src/responses/DiffSummary.js) \|
56	\| `.env(name, value)` \| Set environment variables to be passed to the spawned child processes, [see usage in detail below](#environment-variables). \|
57	\| `.exec(handlerFn)` \| calls a simple function in the current step \|
58	\| `.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) \|
59	\| `.fetch(remote, branch, handlerFn)` \| update the local working copy database with changes from a remote repo \|
60	\| `.fetch(handlerFn)` \| update the local working copy database with changes from the default remote repo and branch \|
61	\| `.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 \|
62	\| `.init(bare, handlerFn)` \| initialize a repository, optional `bare` parameter makes intialized repository bare \|
63	\| `.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))` \|
64	\| `.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. \|
65	\| `.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 \|
66	\| `.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) \|
67	\| `.mirror(repoPath, localPath, handlerFn])` \| clone and mirror the repo to local \|
68	\| `.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) \|
69	\| `.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) \|
70	\| `.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 \|
71	\| `.pull(handlerFn)` \| Pulls all updates from the default tracked repo \|
72	\| `.pull(remote, branch, handlerFn)` \| pull all updates from the specified remote branch (eg 'origin'/'master') \|
73	\| `.pull(remote, branch, options, handlerFn)` \| Pulls from named remote with any necessary options \|
74	\| `.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. \|
75	\| `.pushTags(remote, handlerFn)` \| pushes tags to a named remote \|
76	\| `.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. \|
77	\| `.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). \|
78	\| `.removeRemote(name, handlerFn)` \| removes the named remote \|
79	\| `.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) \|
80	\| `.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). \|
81	\| `.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) \|
82	\| `.rm([fileA, ...], handlerFn)` \| removes any number of files from source control \|
83	\| `.rmKeepLocal([fileA, ...], handlerFn)` \| removes files from source control but leaves them on disk \|
84	\| `.silent(isSilent)` \| sets whether the console should be used for logging errors (defaults to `true` when the `NODE_ENV` contains the string `prod`) \|
85	\| `.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. \|
86	\| `.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. \|
87	\| `.subModule(args [, handlerFn])` \| Run a `git submodule` command with on or more arguments passed in as an `args` array \|
88	\| `.submoduleAdd(repo, path[, handlerFn])` \| adds a new sub module \|
89	\| `.submoduleInit([args, ][handlerFn])` \| inits sub modules, args should be an array of string arguments to pass to the `git submodule init` command \|
90	\| `.submoduleUpdate([args, ][handlerFn])` \| updates sub modules, args should be an array of string arguments to pass to the `git submodule update` command \|
91	\| `.tag(args[], handlerFn)` \| Runs any supported [git tag](https://git-scm.com/docs/git-tag) commands with arguments passed as an array of strings . \|
92	\| `.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. \|
93	\| `.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 \|
94	\| `.status(handlerFn)` \| gets the status of the current repo \|
95
96	# How to Specify Options
97
98	For `.pull` or `.commit` options are included as an object, the keys of which will all be merged as trailing
99	arguments in the command string. When the value of the property in the options object is a `string`, that name value
100	pair will be included in the command string as `name=value`. For example:
101
102	```js
103	// results in 'git pull origin master --no-rebase'
104	git().pull('origin', 'master', {'--no-rebase': null})
105
106	// results in 'git pull origin master --rebase=true'
107	git().pull('origin', 'master', {'--rebase': 'true'})
108	```
109
110	# Release History
111
112	Bumped to a new major revision in the 1.x branch, now uses `ChildProcess.spawn` in place of `ChildProcess.exec` to
113	add escaping to the arguments passed to each of the tasks.
114
115	# Deprecated APIs
116
117	Use of these APIs is deprecated and should be avoided as support for them will be removed in future release:
118
119	`.then(func)` In versions 1.72 and below, it was possible to add a regular function call to the queue of tasks to be
120	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
121	be logged to `stdout` if `.then` is used. From version 2.0 the library will support promises without the need to wrap
122	or use the alternative require `require('simple-git/promise')`.
123
124	`.log([from, to], handlerFn)` list commits between `from` and `to` tags or branch, switch to supplying the revisions
125	as an options object instead.
126
127	# Complex Requests
128
129	When no suitable wrapper exists in the interface for creating a request, it is possible to run a command directly
130	using `git.raw([...], handler)`. The array of commands are passed directly to the `git` binary:
131
132	```js
133	const git = require('simple-git');
134	const path = '/path/to/repo';
135
136	git(path).raw(
137	[
138	'config',
139	'--global',
140	'advice.pushNonFastForward',
141	'false'
142	], (err, result) => {
143
144	// err is null unless this command failed
145	// result is the raw output of this command
146
147	});
148	```
149
150	# Authentication
151
152	The easiest way to supply a username / password to the remote host is to include it in the URL, for example:
153
154	```js
155	const USER = 'something';
156	const PASS = 'somewhere';
157	const REPO = 'github.com/username/private-repo';
158
159	const git = require('simple-git/promise');
160	const remote = `https://${USER}:${PASS}@${REPO}`;
161
162	git().silent(true)
163	.clone(remote)
164	.then(() => console.log('finished'))
165	.catch((err) => console.error('failed: ', err));
166
167	```
168
169	Be sure to enable silent mode to prevent fatal errors from being logged to stdout.
170
171	# Environment Variables
172
173	Pass one or more environment variables to the child processes spawned by `simple-git` with the `.env` method which
174	supports passing either an object of name=value pairs or setting a single variable at a time:
175
176	```js
177	const GIT_SSH_COMMAND = "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no";
178
179	const git = require('simple-git');
180
181	git()
182	.env('GIT_SSH_COMMAND', GIT_SSH_COMMAND)
183	.status((err, status) => { /* */ })
184
185
186	const gitP = require('simple-git/promise');
187
188	gitP().env({ ...process.env, GIT_SSH_COMMAND })
189	.status()
190	.then(status => { })
191	.catch(err => {});
192
193	```
194
195	Note - when passing environment variables into the child process, these will replace the standard `process.env`
196	variables, the example above creates a new object based on `process.env` but with the `GIT_SSH_COMMAND` property
197	added.
198
199	# TypeScript
200
201	To import with TypeScript:
202
203	```typescript
204	import gitP, { SimpleGit, StatusResult } from 'simple-git/promise';
205
206	const git: SimpleGit = gitP();
207	const status: StatusResult = await git.status();
208	```
209
210	# Promise and async compatible
211
212	To work with promises (either directly or as part of async/await), load the promise wrappers library:
213
214	```js
215	const simpleGit = require('simple-git/promise');
216	const git = simpleGit();
217
218	const status = await git.status();
219	```
220
221	Exceptions (generally recognised by the git process exiting with a non-zero status, or in some cases
222	like `merge` the git process exits with a successful zero code but there are conflicts in the merge)
223	should be handled by catching:
224
225	```js
226	try {
227	const mergeSummary = await git.merge();
228	console.log(`Merged ${ mergeSummary.merges.length } files`);
229	}
230	catch (err) {
231	// err.message - the string summary of the error
232	// err.stack - some stack trace detail
233	// err.git - where a parser was able to run, this is the parsed content
234
235	console.error(`Merge resulted in ${ err.git.conflicts.length } conflicts`);
236	}
237	```
238
239	# Response Object Revisions
240
241	\| Class \| Version \| Change \|
242	\| 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' }` \|
243	\| 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' }` \|
244
245	# Troubleshooting
246
247	### Every command returns ENOENT error message
248
249	There are a few potential reasons:
250
251	- `git` isn't available as a binary for the user running the main `node` process, custom paths to the binary can be used
252	with the `.customBinary(...)` api option.
253	- the working directory passed in to the main `simple-git` function isn't accessible, check it is read/write accessible
254	by the user running the `node` process.
255
256	### Log response properties are out of order
257
258	The properties of `git.log` are fetched using a `;` as a delimiter. If your commit messages use the `;` character,
259	supply a custom `splitter` in the options, for example: `git.log({ splitter: '\|\|\|' })`
260
261	# Examples
262
263	### async await with simple-git/promise:
264
265	```js
266	async function status (workingDir) {
267	const git = require('simple-git/promise');
268
269	let statusSummary = null;
270	try {
271	statusSummary = await git(workingDir).status();
272	}
273	catch (e) {
274	// handle the error
275	}
276
277	return statusSummary;
278	}
279
280	// using the async function
281	status(__dirname + '/some-repo').then(status => console.log(status));
282	```
283
284	### Initialise a git repo if necessary
285	```js
286	const gitP = require('simple-git/promise');
287	const git = gitP(__dirname);
288
289	git.checkIsRepo()
290	.then(isRepo => !isRepo && initialiseRepo(git))
291	.then(() => git.fetch());
292
293	function initialiseRepo (git) {
294	return git.init()
295	.then(() => git.addRemote('origin', 'https://some.git.repo'))
296	}
297	```
298
299	### Update repo and get a list of tags
300	```js
301	require('simple-git')(__dirname + '/some-repo')
302	.pull()
303	.tags((err, tags) => console.log("Latest available tag: %s", tags.latest));
304
305	// update repo and when there are changes, restart the app
306	require('simple-git')()
307	.pull((err, update) => {
308	if(update && update.summary.changes) {
309	require('child_process').exec('npm restart');
310	}
311	});
312	```
313
314	### Starting a new repo
315	```js
316	require('simple-git')()
317	.init()
318	.add('./*')
319	.commit("first commit!")
320	.addRemote('origin', 'https://github.com/user/repo.git')
321	.push('origin', 'master');
322	```
323
324	### push with `-u`
325	```js
326	require('simple-git')()
327	.add('./*')
328	.commit("first commit!")
329	.addRemote('origin', 'some-repo-url')
330	.push(['-u', 'origin', 'master'], () => console.log('done'));
331	```
332
333	### Piping to the console for long running tasks
334	```js
335	require('simple-git')()
336	.outputHandler((command, stdout, stderr) => {
337	stdout.pipe(process.stdout);
338	stderr.pipe(process.stderr);
339	})
340	.checkout('https://github.com/user/repo.git');
341	```
342
343	### Update repo and print messages when there are changes, restart the app
344	```js
345	require('simple-git')()
346	.exec(() => console.log('Starting pull...'))
347	.pull((err, update) => {
348	if(update && update.summary.changes) {
349	require('child_process').exec('npm restart');
350	}
351	})
352	.exec(() => console.log('pull done.'));
353	```
354
355	### Get a full commits list, and then only between 0.11.0 and 0.12.0 tags
356	```js
357	require('simple-git')()
358	.log((err, log) => console.log(log))
359	.log('0.11.0', '0.12.0', (err, log) => console.log(log));
360	```
361
362	### Set the local configuration for author, then author for an individual commit
363	```js
364	require('simple-git')()
365	.addConfig('user.name', 'Some One')
366	.addConfig('user.email', 'some@one.com')
367	.commit('committed as "Some One"', 'file-one')
368	.commit('committed as "Another Person"', 'file-two', { '--author': '"Another Person <another@person.com>"' });
369	```
370
371	### Get remote repositories
372	```js
373	require('simple-git')()
374	.listRemote(['--get-url'], (err, data) => {
375	if (!err) {
376	console.log('Remote url for repository at ' + __dirname + ':');
377	console.log(data);
378	}
379	});
380	```

node_modules/simple-git/src/git.js+0−1592

@@ -1,1592 +0,0 @@
1	(function () {
2
3	'use strict';
4
5	var debug = require('debug')('simple-git');
6	var deferred = require('./util/deferred');
7	var exists = require('./util/exists');
8	var NOOP = function () {};
9	var responses = require('./responses');
10
11	/**
12	* Git handling for node. All public functions can be chained and all `then` handlers are optional.
13	*
14	* @param {string} baseDir base directory for all processes to run
15	*
16	* @param {Object} ChildProcess The ChildProcess module
17	* @param {Function} Buffer The Buffer implementation to use
18	*
19	* @constructor
20	*/
21	function Git (baseDir, ChildProcess, Buffer) {
22	this._baseDir = baseDir;
23	this._runCache = [];
24
25	this.ChildProcess = ChildProcess;
26	this.Buffer = Buffer;
27	}
28
29	/**
30	* @type {string} The command to use to reference the git binary
31	*/
32	Git.prototype._command = 'git';
33
34	/**
35	* @type {[key: string]: string} An object of key=value pairs to be passed as environment variables to the
36	* spawned child process.
37	*/
38	Git.prototype._env = null;
39
40	/**
41	* @type {Function} An optional handler to use when a child process is created
42	*/
43	Git.prototype._outputHandler = null;
44
45	/**
46	* @type {boolean} Property showing whether logging will be silenced - defaults to true in a production environment
47	*/
48	Git.prototype._silentLogging = /prod/.test(process.env.NODE_ENV);
49
50	/**
51	* Sets the path to a custom git binary, should either be `git` when there is an installation of git available on
52	* the system path, or a fully qualified path to the executable.
53	*
54	* @param {string} command
55	* @returns {Git}
56	*/
57	Git.prototype.customBinary = function (command) {
58	this._command = command;
59	return this;
60	};
61
62	/**
63	* Sets an environment variable for the spawned child process, either supply both a name and value as strings or
64	* a single object to entirely replace the current environment variables.
65	*
66	* @param {string\|Object} name
67	* @param {string} [value]
68	* @returns {Git}
69	*/
70	Git.prototype.env = function (name, value) {
71	if (arguments.length === 1 && typeof name === 'object') {
72	this._env = name;
73	}
74	else {
75	(this._env = this._env \|\| {})[name] = value;
76	}
77
78	return this;
79	};
80
81	/**
82	* Sets the working directory of the subsequent commands.
83	*
84	* @param {string} workingDirectory
85	* @param {Function} [then]
86	* @returns {Git}
87	*/
88	Git.prototype.cwd = function (workingDirectory, then) {
89	var git = this;
90	var next = Git.trailingFunctionArgument(arguments);
91
92	return this.exec(function () {
93	git._baseDir = workingDirectory;
94	if (!exists(workingDirectory, exists.FOLDER)) {
95	Git.exception(git, 'Git.cwd: cannot change to non-directory "' + workingDirectory + '"', next);
96	}
97	else {
98	next && next(null, workingDirectory);
99	}
100	});
101	};
102
103	/**
104	* Sets a handler function to be called whenever a new child process is created, the handler function will be called
105	* with the name of the command being run and the stdout & stderr streams used by the ChildProcess.
106	*
107	* @example
108	* require('simple-git')
109	* .outputHandler(function (command, stdout, stderr) {
110	* stdout.pipe(process.stdout);
111	* })
112	* .checkout('https://github.com/user/repo.git');
113	*
114	* @see https://nodejs.org/api/child_process.html#child_process_class_childprocess
115	* @see https://nodejs.org/api/stream.html#stream_class_stream_readable
116	* @param {Function} outputHandler
117	* @returns {Git}
118	*/
119	Git.prototype.outputHandler = function (outputHandler) {
120	this._outputHandler = outputHandler;
121	return this;
122	};
123
124	/**
125	* Initialize a git repo
126	*
127	* @param {Boolean} [bare=false]
128	* @param {Function} [then]
129	*/
130	Git.prototype.init = function (bare, then) {
131	var commands = ['init'];
132	var next = Git.trailingFunctionArgument(arguments);
133
134	if (bare === true) {
135	commands.push('--bare');
136	}
137
138	return this._run(commands, function (err) {
139	next && next(err);
140	});
141	};
142
143	/**
144	* Check the status of the local repo
145	*
146	* @param {Function} [then]
147	*/
148	Git.prototype.status = function (then) {
149	return this._run(
150	['status', '--porcelain', '-b', '-u'],
151	Git._responseHandler(then, 'StatusSummary')
152	);
153	};
154
155	/**
156	* List the stash(s) of the local repo
157	*
158	* @param {Object\|Array} [options]
159	* @param {Function} [then]
160	*/
161	Git.prototype.stashList = function (options, then) {
162	var handler = Git.trailingFunctionArgument(arguments);
163	var opt = (handler === then ? options : null) \|\| {};
164
165	var splitter = opt.splitter \|\| requireResponseHandler('ListLogSummary').SPLITTER;
166	var command = ["stash", "list", "--pretty=format:"
167	+ requireResponseHandler('ListLogSummary').START_BOUNDARY
168	+ "%H %ai %s%d %aN %ae".replace(/\s+/g, splitter)
169	+ requireResponseHandler('ListLogSummary').COMMIT_BOUNDARY
170	];
171
172	if (Array.isArray(opt)) {
173	command = command.concat(opt);
174	}
175
176	return this._run(command,
177	Git._responseHandler(handler, 'ListLogSummary', splitter)
178	);
179	};
180
181	/**
182	* Stash the local repo
183	*
184	* @param {Object\|Array} [options]
185	* @param {Function} [then]
186	*/
187	Git.prototype.stash = function (options, then) {
188	var command = ['stash'];
189	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
190	command.push.apply(command, Git.trailingArrayArgument(arguments));
191
192	return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
193	};
194
195	/**
196	* Clone a git repo
197	*
198	* @param {string} repoPath
199	* @param {string} localPath
200	* @param {String[]} [options] Optional array of options to pass through to the clone command
201	* @param {Function} [then]
202	*/
203	Git.prototype.clone = function (repoPath, localPath, options, then) {
204	var next = Git.trailingFunctionArgument(arguments);
205	var command = ['clone'].concat(Git.trailingArrayArgument(arguments));
206
207	for (var i = 0, iMax = arguments.length; i < iMax; i++) {
208	if (typeof arguments[i] === 'string') {
209	command.push(arguments[i]);
210	}
211	}
212
213	return this._run(command, function (err, data) {
214	next && next(err, data);
215	});
216	};
217
218	/**
219	* Mirror a git repo
220	*
221	* @param {string} repoPath
222	* @param {string} localPath
223	* @param {Function} [then]
224	*/
225	Git.prototype.mirror = function (repoPath, localPath, then) {
226	return this.clone(repoPath, localPath, ['--mirror'], then);
227	};
228
229	/**
230	* Moves one or more files to a new destination.
231	*
232	* @see https://git-scm.com/docs/git-mv
233	*
234	* @param {string\|string[]} from
235	* @param {string} to
236	* @param {Function} [then]
237	*/
238	Git.prototype.mv = function (from, to, then) {
239	var handler = Git.trailingFunctionArgument(arguments);
240
241	var command = [].concat(from);
242	command.unshift('mv', '-v');
243	command.push(to);
244
245	this._run(command, Git._responseHandler(handler, 'MoveSummary'))
246	};
247
248	/**
249	* Internally uses pull and tags to get the list of tags then checks out the latest tag.
250	*
251	* @param {Function} [then]
252	*/
253	Git.prototype.checkoutLatestTag = function (then) {
254	var git = this;
255	return this.pull(function () {
256	git.tags(function (err, tags) {
257	git.checkout(tags.latest, then);
258	});
259	});
260	};
261
262	/**
263	* Adds one or more files to source control
264	*
265	* @param {string\|string[]} files
266	* @param {Function} [then]
267	*/
268	Git.prototype.add = function (files, then) {
269	return this._run(['add'].concat(files), function (err, data) {
270	then && then(err);
271	});
272	};
273
274	/**
275	* Commits changes in the current working directory - when specific file paths are supplied, only changes on those
276	* files will be committed.
277	*
278	* @param {string\|string[]} message
279	* @param {string\|string[]} [files]
280	* @param {Object} [options]
281	* @param {Function} [then]
282	*/
283	Git.prototype.commit = function (message, files, options, then) {
284	var handler = Git.trailingFunctionArgument(arguments);
285
286	var command = ['commit'];
287
288	[].concat(message).forEach(function (message) {
289	command.push('-m', message);
290	});
291
292	[].push.apply(command, [].concat(typeof files === "string" \|\| Array.isArray(files) ? files : []));
293
294	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
295
296	return this._run(
297	command,
298	Git._responseHandler(handler, 'CommitSummary')
299	);
300	};
301
302	/**
303	* Gets a function to be used for logging.
304	*
305	* @param {string} level
306	* @param {string} [message]
307	*
308	* @returns {Function}
309	* @private
310	*/
311	Git.prototype._getLog = function (level, message) {
312	var log = this._silentLogging ? NOOP : console[level].bind(console);
313	if (arguments.length > 1) {
314	log(message);
315	}
316	return log;
317	};
318
319	/**
320	* Pull the updated contents of the current repo
321	*
322	* @param {string} [remote] When supplied must also include the branch
323	* @param {string} [branch] When supplied must also include the remote
324	* @param {Object} [options] Optionally include set of options to merge into the command
325	* @param {Function} [then]
326	*/
327	Git.prototype.pull = function (remote, branch, options, then) {
328	var command = ["pull"];
329	var handler = Git.trailingFunctionArgument(arguments);
330
331	if (typeof remote === 'string' && typeof branch === 'string') {
332	command.push(remote, branch);
333	}
334
335	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
336
337	return this._run(command, Git._responseHandler(handler, 'PullSummary'));
338	};
339
340	/**
341	* Fetch the updated contents of the current repo.
342	*
343	* @example
344	* .fetch('upstream', 'master') // fetches from master on remote named upstream
345	* .fetch(function () {}) // runs fetch against default remote and branch and calls function
346	*
347	* @param {string} [remote]
348	* @param {string} [branch]
349	* @param {Function} [then]
350	*/
351	Git.prototype.fetch = function (remote, branch, then) {
352	var command = ["fetch"];
353	var next = Git.trailingFunctionArgument(arguments);
354	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
355
356	if (typeof remote === 'string' && typeof branch === 'string') {
357	command.push(remote, branch);
358	}
359
360	if (Array.isArray(remote)) {
361	command = command.concat(remote);
362	}
363
364	return this._run(
365	command,
366	Git._responseHandler(next, 'FetchSummary'),
367	{
368	concatStdErr: true
369	}
370	);
371	};
372
373	/**
374	* Disables/enables the use of the console for printing warnings and errors, by default messages are not shown in
375	* a production environment.
376	*
377	* @param {boolean} silence
378	* @returns {Git}
379	*/
380	Git.prototype.silent = function (silence) {
381	this._silentLogging = !!silence;
382	return this;
383	};
384
385	/**
386	* List all tags. When using git 2.7.0 or above, include an options object with `"--sort": "property-name"` to
387	* sort the tags by that property instead of using the default semantic versioning sort.
388	*
389	* Note, supplying this option when it is not supported by your Git version will cause the operation to fail.
390	*
391	* @param {Object} [options]
392	* @param {Function} [then]
393	*/
394	Git.prototype.tags = function (options, then) {
395	var next = Git.trailingFunctionArgument(arguments);
396
397	var command = ['-l'];
398	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
399
400	var hasCustomSort = command.some(function (option) {
401	return /^--sort=/.test(option);
402	});
403
404	return this.tag(
405	command,
406	Git._responseHandler(next, 'TagList', [hasCustomSort])
407	);
408	};
409
410	/**
411	* Rebases the current working copy. Options can be supplied either as an array of string parameters
412	* to be sent to the `git rebase` command, or a standard options object.
413	*
414	* @param {Object\|String[]} [options]
415	* @param {Function} [then]
416	* @returns {Git}
417	*/
418	Git.prototype.rebase = function (options, then) {
419	var command = ['rebase'];
420	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
421	command.push.apply(command, Git.trailingArrayArgument(arguments));
422
423
424	return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
425	};
426
427	/**
428	* Reset a repo
429	*
430	* @param {string\|string[]} [mode=soft] Either an array of arguments supported by the 'git reset' command, or the
431	* string value 'soft' or 'hard' to set the reset mode.
432	* @param {Function} [then]
433	*/
434	Git.prototype.reset = function (mode, then) {
435	var command = ['reset'];
436	var next = Git.trailingFunctionArgument(arguments);
437	if (next === mode \|\| typeof mode === 'string' \|\| !mode) {
438	var modeStr = ['mixed', 'soft', 'hard'].includes(mode) ? mode : 'soft';
439	command.push('--' + modeStr);
440	}
441	else if (Array.isArray(mode)) {
442	command.push.apply(command, mode);
443	}
444
445	return this._run(command, function (err) {
446	next && next(err \|\| null);
447	});
448	};
449
450	/**
451	* Revert one or more commits in the local working copy
452	*
453	* @param {string} commit The commit to revert. Can be any hash, offset (eg: `HEAD~2`) or range (eg: `master~5..master~2`)
454	* @param {Object} [options] Optional options object
455	* @param {Function} [then]
456	*/
457	Git.prototype.revert = function (commit, options, then) {
458	var next = Git.trailingFunctionArgument(arguments);
459	var command = ['revert'];
460
461	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
462
463	if (typeof commit !== 'string') {
464	return this.exec(function () {
465	next && next(new TypeError("Commit must be a string"));
466	});
467	}
468
469	command.push(commit);
470	return this._run(command, function (err) {
471	next && next(err \|\| null);
472	});
473	};
474
475	/**
476	* Add a lightweight tag to the head of the current branch
477	*
478	* @param {string} name
479	* @param {Function} [then]
480	*/
481	Git.prototype.addTag = function (name, then) {
482	if (typeof name !== "string") {
483	return this.exec(function () {
484	then && then(new TypeError("Git.addTag requires a tag name"));
485	});
486	}
487
488	var command = [name];
489	return then ? this.tag(command, then) : this.tag(command);
490	};
491
492	/**
493	* Add an annotated tag to the head of the current branch
494	*
495	* @param {string} tagName
496	* @param {string} tagMessage
497	* @param {Function} [then]
498	*/
499	Git.prototype.addAnnotatedTag = function (tagName, tagMessage, then) {
500	return this.tag(['-a', '-m', tagMessage, tagName], function (err) {
501	then && then(err);
502	});
503	};
504
505	/**
506	* Check out a tag or revision, any number of additional arguments can be passed to the `git checkout` command
507	* by supplying either a string or array of strings as the `what` parameter.
508	*
509	* @param {string\|string[]} what One or more commands to pass to `git checkout`
510	* @param {Function} [then]
511	*/
512	Git.prototype.checkout = function (what, then) {
513	var command = ['checkout'];
514	command = command.concat(what);
515
516	return this._run(command, function (err, data) {
517	then && then(err, !err && this._parseCheckout(data));
518	});
519	};
520
521	/**
522	* Check out a remote branch
523	*
524	* @param {string} branchName name of branch
525	* @param {string} startPoint (e.g origin/development)
526	* @param {Function} [then]
527	*/
528	Git.prototype.checkoutBranch = function (branchName, startPoint, then) {
529	return this.checkout(['-b', branchName, startPoint], then);
530	};
531
532	/**
533	* Check out a local branch
534	*
535	* @param {string} branchName of branch
536	* @param {Function} [then]
537	*/
538	Git.prototype.checkoutLocalBranch = function (branchName, then) {
539	return this.checkout(['-b', branchName], then);
540	};
541
542	/**
543	* Delete a local branch
544	*
545	* @param {string} branchName name of branch
546	* @param {Function} [then]
547	*/
548	Git.prototype.deleteLocalBranch = function (branchName, then) {
549	return this.branch(['-d', branchName], then);
550	};
551
552	/**
553	* List all branches
554	*
555	* @param {Object \| string[]} [options]
556	* @param {Function} [then]
557	*/
558	Git.prototype.branch = function (options, then) {
559	var isDelete, responseHandler;
560	var next = Git.trailingFunctionArgument(arguments);
561	var command = ['branch'];
562
563	command.push.apply(command, Git.trailingArrayArgument(arguments));
564	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
565
566	if (!arguments.length \|\| next === options) {
567	command.push('-a');
568	}
569
570	isDelete = ['-d', '-D', '--delete'].reduce(function (isDelete, flag) {
571	return isDelete \|\| command.indexOf(flag) > 0;
572	}, false);
573
574	if (command.indexOf('-v') < 0) {
575	command.splice(1, 0, '-v');
576	}
577
578	responseHandler = isDelete
579	? Git._responseHandler(next, 'BranchDeleteSummary', false)
580	: Git._responseHandler(next, 'BranchSummary');
581
582	return this._run(command, responseHandler);
583	};
584
585	/**
586	* Return list of local branches
587	*
588	* @param {Function} [then]
589	*/
590	Git.prototype.branchLocal = function (then) {
591	return this.branch(['-v'], then);
592	};
593
594	/**
595	* Add config to local git instance
596	*
597	* @param {string} key configuration key (e.g user.name)
598	* @param {string} value for the given key (e.g your name)
599	* @param {Function} [then]
600	*/
601	Git.prototype.addConfig = function (key, value, then) {
602	return this._run(['config', '--local', key, value], function (err, data) {
603	then && then(err, !err && data);
604	});
605	};
606
607	/**
608	* Executes any command against the git binary.
609	*
610	* @param {string[]\|Object} commands
611	* @param {Function} [then]
612	*
613	* @returns {Git}
614	*/
615	Git.prototype.raw = function (commands, then) {
616	var command = [];
617	if (Array.isArray(commands)) {
618	command = commands.slice(0);
619	}
620	else {
621	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
622	}
623
624	var next = Git.trailingFunctionArgument(arguments);
625
626	if (!command.length) {
627	return this.exec(function () {
628	next && next(new Error('Raw: must supply one or more command to execute'), null);
629	});
630	}
631
632	return this._run(command, function (err, data) {
633	next && next(err, !err && data \|\| null);
634	});
635	};
636
637	/**
638	* Add a submodule
639	*
640	* @param {string} repo
641	* @param {string} path
642	* @param {Function} [then]
643	*/
644	Git.prototype.submoduleAdd = function (repo, path, then) {
645	return this._run(['submodule', 'add', repo, path], function (err) {
646	then && then(err);
647	});
648	};
649
650	/**
651	* Update submodules
652	*
653	* @param {string[]} [args]
654	* @param {Function} [then]
655	*/
656	Git.prototype.submoduleUpdate = function (args, then) {
657	if (typeof args === 'string') {
658	this._getLog('warn', 'Git#submoduleUpdate: args should be supplied as an array of individual arguments');
659	}
660
661	var next = Git.trailingFunctionArgument(arguments);
662	var command = (args !== next) ? args : [];
663
664	return this.subModule(['update'].concat(command), function (err, args) {
665	next && next(err, args);
666	});
667	};
668
669	/**
670	* Initialize submodules
671	*
672	* @param {string[]} [args]
673	* @param {Function} [then]
674	*/
675	Git.prototype.submoduleInit = function (args, then) {
676	if (typeof args === 'string') {
677	this._getLog('warn', 'Git#submoduleInit: args should be supplied as an array of individual arguments');
678	}
679
680	var next = Git.trailingFunctionArgument(arguments);
681	var command = (args !== next) ? args : [];
682
683	return this.subModule(['init'].concat(command), function (err, args) {
684	next && next(err, args);
685	});
686	};
687
688	/**
689	* Call any `git submodule` function with arguments passed as an array of strings.
690	*
691	* @param {string[]} options
692	* @param {Function} [then]
693	*/
694	Git.prototype.subModule = function (options, then) {
695	if (!Array.isArray(options)) {
696	return this.exec(function () {
697	then && then(new TypeError("Git.subModule requires an array of arguments"));
698	});
699	}
700
701	if (options[0] !== 'submodule') {
702	options.unshift('submodule');
703	}
704
705	return this._run(options, function (err, data) {
706	then && then(err \|\| null, err ? null : data);
707	});
708	};
709
710	/**
711	* List remote
712	*
713	* @param {string[]} [args]
714	* @param {Function} [then]
715	*/
716	Git.prototype.listRemote = function (args, then) {
717	var next = Git.trailingFunctionArgument(arguments);
718	var data = next === args \|\| args === undefined ? [] : args;
719
720	if (typeof data === 'string') {
721	this._getLog('warn', 'Git#listRemote: args should be supplied as an array of individual arguments');
722	}
723
724	return this._run(['ls-remote'].concat(data), function (err, data) {
725	next && next(err, data);
726	});
727	};
728
729	/**
730	* Adds a remote to the list of remotes.
731	*
732	* @param {string} remoteName Name of the repository - eg "upstream"
733	* @param {string} remoteRepo Fully qualified SSH or HTTP(S) path to the remote repo
734	* @param {Function} [then]
735	* @returns {*}
736	*/
737	Git.prototype.addRemote = function (remoteName, remoteRepo, then) {
738	return this._run(['remote', 'add', remoteName, remoteRepo], function (err) {
739	then && then(err);
740	});
741	};
742
743	/**
744	* Removes an entry from the list of remotes.
745	*
746	* @param {string} remoteName Name of the repository - eg "upstream"
747	* @param {Function} [then]
748	* @returns {*}
749	*/
750	Git.prototype.removeRemote = function (remoteName, then) {
751	return this._run(['remote', 'remove', remoteName], function (err) {
752	then && then(err);
753	});
754	};
755
756	/**
757	* Gets the currently available remotes, setting the optional verbose argument to true includes additional
758	* detail on the remotes themselves.
759	*
760	* @param {boolean} [verbose=false]
761	* @param {Function} [then]
762	*/
763	Git.prototype.getRemotes = function (verbose, then) {
764	var next = Git.trailingFunctionArgument(arguments);
765	var args = verbose === true ? ['-v'] : [];
766
767	return this.remote(args, function (err, data) {
768	next && next(err, !err && function () {
769	return data.trim().split('\n').filter(Boolean).reduce(function (remotes, remote) {
770	var detail = remote.trim().split(/\s+/);
771	var name = detail.shift();
772
773	if (!remotes[name]) {
774	remotes[name] = remotes[remotes.length] = {
775	name: name,
776	refs: {}
777	};
778	}
779
780	if (detail.length) {
781	remotes[name].refs[detail.pop().replace(/[^a-z]/g, '')] = detail.pop();
782	}
783
784	return remotes;
785	}, []).slice(0);
786	}());
787	});
788	};
789
790	/**
791	* Call any `git remote` function with arguments passed as an array of strings.
792	*
793	* @param {string[]} options
794	* @param {Function} [then]
795	*/
796	Git.prototype.remote = function (options, then) {
797	if (!Array.isArray(options)) {
798	return this.exec(function () {
799	then && then(new TypeError("Git.remote requires an array of arguments"));
800	});
801	}
802
803	if (options[0] !== 'remote') {
804	options.unshift('remote');
805	}
806
807	return this._run(options, function (err, data) {
808	then && then(err \|\| null, err ? null : data);
809	});
810	};
811
812	/**
813	* Merges from one branch to another, equivalent to running `git merge ${from} $[to}`, the `options` argument can
814	* either be an array of additional parameters to pass to the command or null / omitted to be ignored.
815	*
816	* @param {string} from
817	* @param {string} to
818	* @param {string[]} [options]
819	* @param {Function} [then]
820	*/
821	Git.prototype.mergeFromTo = function (from, to, options, then) {
822	var commands = [
823	from,
824	to
825	];
826	var callback = Git.trailingFunctionArgument(arguments);
827
828	if (Array.isArray(options)) {
829	commands = commands.concat(options);
830	}
831
832	return this.merge(commands, callback);
833	};
834
835	/**
836	* Runs a merge, `options` can be either an array of arguments
837	* supported by the [`git merge`](https://git-scm.com/docs/git-merge)
838	* or an options object.
839	*
840	* Conflicts during the merge result in an error response,
841	* the response type whether it was an error or success will be a MergeSummary instance.
842	* When successful, the MergeSummary has all detail from a the PullSummary
843	*
844	* @param {Object \| string[]} [options]
845	* @param {Function} [then]
846	* @returns {*}
847	*
848	* @see ./responses/MergeSummary.js
849	* @see ./responses/PullSummary.js
850	*/
851	Git.prototype.merge = function (options, then) {
852	var self = this;
853	var userHandler = Git.trailingFunctionArgument(arguments) \|\| NOOP;
854	var mergeHandler = function (err, mergeSummary) {
855	if (!err && mergeSummary.failed) {
856	return Git.fail(self, mergeSummary, userHandler);
857	}
858
859	userHandler(err, mergeSummary);
860	};
861
862	var command = [];
863	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
864	command.push.apply(command, Git.trailingArrayArgument(arguments));
865
866	if (command[0] !== 'merge') {
867	command.unshift('merge');
868	}
869
870	if (command.length === 1) {
871	return this.exec(function () {
872	then && then(new TypeError("Git.merge requires at least one option"));
873	});
874	}
875
876	return this._run(command, Git._responseHandler(mergeHandler, 'MergeSummary'), {
877	concatStdErr: true
878	});
879	};
880
881	/**
882	* Call any `git tag` function with arguments passed as an array of strings.
883	*
884	* @param {string[]} options
885	* @param {Function} [then]
886	*/
887	Git.prototype.tag = function (options, then) {
888	var command = [];
889	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
890	command.push.apply(command, Git.trailingArrayArgument(arguments));
891
892	if (command[0] !== 'tag') {
893	command.unshift('tag');
894	}
895
896	return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
897	};
898
899	/**
900	* Updates repository server info
901	*
902	* @param {Function} [then]
903	*/
904	Git.prototype.updateServerInfo = function (then) {
905	return this._run(["update-server-info"], function (err, data) {
906	then && then(err, !err && data);
907	});
908	};
909
910	/**
911	* Pushes the current committed changes to a remote, optionally specify the names of the remote and branch to use
912	* when pushing. Supply multiple options as an array of strings in the first argument - see examples below.
913	*
914	* @param {string\|string[]} [remote]
915	* @param {string} [branch]
916	* @param {Function} [then]
917	*/
918	Git.prototype.push = function (remote, branch, then) {
919	var command = [];
920	var handler = Git.trailingFunctionArgument(arguments);
921
922	if (typeof remote === 'string' && typeof branch === 'string') {
923	command.push(remote, branch);
924	}
925
926	if (Array.isArray(remote)) {
927	command = command.concat(remote);
928	}
929
930	Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
931
932	if (command[0] !== 'push') {
933	command.unshift('push');
934	}
935
936	return this._run(command, function (err, data) {
937	handler && handler(err, !err && data);
938	});
939	};
940
941	/**
942	* Pushes the current tag changes to a remote which can be either a URL or named remote. When not specified uses the
943	* default configured remote spec.
944	*
945	* @param {string} [remote]
946	* @param {Function} [then]
947	*/
948	Git.prototype.pushTags = function (remote, then) {
949	var command = ['push'];
950	if (typeof remote === "string") {
951	command.push(remote);
952	}
953	command.push('--tags');
954
955	then = typeof arguments[arguments.length - 1] === "function" ? arguments[arguments.length - 1] : null;
956
957	return this._run(command, function (err, data) {
958	then && then(err, !err && data);
959	});
960	};
961
962	/**
963	* Removes the named files from source control.
964	*
965	* @param {string\|string[]} files
966	* @param {Function} [then]
967	*/
968	Git.prototype.rm = function (files, then) {
969	return this._rm(files, '-f', then);
970	};
971
972	/**
973	* Removes the named files from source control but keeps them on disk rather than deleting them entirely. To
974	* completely remove the files, use `rm`.
975	*
976	* @param {string\|string[]} files
977	* @param {Function} [then]
978	*/
979	Git.prototype.rmKeepLocal = function (files, then) {
980	return this._rm(files, '--cached', then);
981	};
982
983	/**
984	* Returns a list of objects in a tree based on commit hash. Passing in an object hash returns the object's content,
985	* size, and type.
986	*
987	* Passing "-p" will instruct cat-file to determine the object type, and display its formatted contents.
988	*
989	* @param {string[]} [options]
990	* @param {Function} [then]
991	*/
992	Git.prototype.catFile = function (options, then) {
993	return this._catFile('utf-8', arguments);
994	};
995
996	/**
997	* Equivalent to `catFile` but will return the native `Buffer` of content from the git command's stdout.
998	*
999	* @param {string[]} options
1000	* @param then
1001	*/
1002	Git.prototype.binaryCatFile = function (options, then) {
1003	return this._catFile('buffer', arguments);
1004	};
1005
1006	Git.prototype._catFile = function (format, args) {
1007	var handler = Git.trailingFunctionArgument(args);
1008	var command = ['cat-file'];
1009	var options = args[0];
1010
1011	if (typeof options === 'string') {
1012	throw new TypeError('Git#catFile: options must be supplied as an array of strings');
1013	}
1014	else if (Array.isArray(options)) {
1015	command.push.apply(command, options);
1016	}
1017
1018	return this._run(command, function (err, data) {
1019	handler && handler(err, data);
1020	}, {
1021	format: format
1022	});
1023	};
1024
1025	/**
1026	* Return repository changes.
1027	*
1028	* @param {string[]} [options]
1029	* @param {Function} [then]
1030	*/
1031	Git.prototype.diff = function (options, then) {
1032	var command = ['diff'];
1033
1034	if (typeof options === 'string') {
1035	command[0] += ' ' + options;
1036	this._getLog('warn',
1037	'Git#diff: supplying options as a single string is now deprecated, switch to an array of strings');
1038	}
1039	else if (Array.isArray(options)) {
1040	command.push.apply(command, options);
1041	}
1042
1043	if (typeof arguments[arguments.length - 1] === 'function') {
1044	then = arguments[arguments.length - 1];
1045	}
1046
1047	return this._run(command, function (err, data) {
1048	then && then(err, data);
1049	});
1050	};
1051
1052	Git.prototype.diffSummary = function (options, then) {
1053	var next = Git.trailingFunctionArgument(arguments);
1054	var command = ['--stat=4096'];
1055
1056	if (options && options !== next) {
1057	command.push.apply(command, [].concat(options));
1058	}
1059
1060	return this.diff(command, Git._responseHandler(next, 'DiffSummary'));
1061	};
1062
1063	/**
1064	* Wraps `git rev-parse`. Primarily used to convert friendly commit references (ie branch names) to SHA1 hashes.
1065	*
1066	* Options should be an array of string options compatible with the `git rev-parse`
1067	*
1068	* @param {string\|string[]} [options]
1069	* @param {Function} [then]
1070	*
1071	* @see https://git-scm.com/docs/git-rev-parse
1072	*/
1073	Git.prototype.revparse = function (options, then) {
1074	var command = ['rev-parse'];
1075
1076	if (typeof options === 'string') {
1077	command = command + ' ' + options;
1078	this._getLog('warn',
1079	'Git#revparse: supplying options as a single string is now deprecated, switch to an array of strings');
1080	}
1081	else if (Array.isArray(options)) {
1082	command.push.apply(command, options);
1083	}
1084
1085	if (typeof arguments[arguments.length - 1] === 'function') {
1086	then = arguments[arguments.length - 1];
1087	}
1088
1089	return this._run(command, function (err, data) {
1090	then && then(err, err ? null : String(data).trim());
1091	});
1092	};
1093
1094	/**
1095	* Show various types of objects, for example the file at a certain commit
1096	*
1097	* @param {string[]} [options]
1098	* @param {Function} [then]
1099	*/
1100	Git.prototype.show = function (options, then) {
1101	var args = [].slice.call(arguments, 0);
1102	var handler = typeof args[args.length - 1] === "function" ? args.pop() : null;
1103	var command = ['show'];
1104	if (typeof options === 'string') {
1105	command = command + ' ' + options;
1106	this._getLog('warn',
1107	'Git#show: supplying options as a single string is now deprecated, switch to an array of strings');
1108	}
1109	else if (Array.isArray(options)) {
1110	command.push.apply(command, options);
1111	}
1112
1113	return this._run(command, function (err, data) {
1114	handler && handler(err, !err && data);
1115	});
1116	};
1117
1118	/**
1119	* @param {string} mode Required parameter "n" or "f"
1120	* @param {string[]} options
1121	* @param {Function} [then]
1122	*/
1123	Git.prototype.clean = function (mode, options, then) {
1124	var handler = Git.trailingFunctionArgument(arguments);
1125
1126	if (typeof mode !== 'string' \|\| !/[nf]/.test(mode)) {
1127	return this.exec(function () {
1128	handler && handler(new TypeError('Git clean mode parameter ("n" or "f") is required'));
1129	});
1130	}
1131
1132	if (/[^dfinqxX]/.test(mode)) {
1133	return this.exec(function () {
1134	handler && handler(new TypeError('Git clean unknown option found in ' + JSON.stringify(mode)));
1135	});
1136	}
1137
1138	var command = ['clean', '-' + mode];
1139	if (Array.isArray(options)) {
1140	command = command.concat(options);
1141	}
1142
1143	if (command.some(interactiveMode)) {
1144	return this.exec(function () {
1145	handler && handler(new TypeError('Git clean interactive mode is not supported'));
1146	});
1147	}
1148
1149	return this._run(command, function (err, data) {
1150	handler && handler(err, !err && data);
1151	});
1152
1153	function interactiveMode (option) {
1154	if (/^-[^\-]/.test(option)) {
1155	return option.indexOf('i') > 0;
1156	}
1157
1158	return option === '--interactive';
1159	}
1160	};
1161
1162	/**
1163	* Call a simple function at the next step in the chain.
1164	* @param {Function} [then]
1165	*/
1166	Git.prototype.exec = function (then) {
1167	this._run([], function () {
1168	typeof then === 'function' && then();
1169	});
1170	return this;
1171	};
1172
1173	/**
1174	* Deprecated means of adding a regular function call at the next step in the chain. Use the replacement
1175	* Git#exec, the Git#then method will be removed in version 2.x
1176	*
1177	* @see exec
1178	* @deprecated
1179	*/
1180	Git.prototype.then = function (then) {
1181	this._getLog(
1182	'error', `
1183	Git#then is deprecated after version 1.72 and will be removed in version 2.x
1184	To use promises switch to importing 'simple-git/promise'.`);
1185
1186	return this.exec(then);
1187	};
1188
1189	/**
1190	* Show commit logs from `HEAD` to the first commit.
1191	* If provided between `options.from` and `options.to` tags or branch.
1192	*
1193	* Additionally you can provide options.file, which is the path to a file in your repository. Then only this file will be considered.
1194	*
1195	* To use a custom splitter in the log format, set `options.splitter` to be the string the log should be split on.
1196	*
1197	* Options can also be supplied as a standard options object for adding custom properties supported by the git log command.
1198	* For any other set of options, supply options as an array of strings to be appended to the git log command.
1199	*
1200	* @param {Object\|string[]} [options]
1201	* @param {string} [options.from] The first commit to include
1202	* @param {string} [options.to] The most recent commit to include
1203	* @param {string} [options.file] A single file to include in the result
1204	* @param {boolean} [options.multiLine] Optionally include multi-line commit messages
1205	*
1206	* @param {Function} [then]
1207	*/
1208	Git.prototype.log = function (options, then) {
1209	var handler = Git.trailingFunctionArgument(arguments);
1210	var opt = (handler === then ? options : null) \|\| {};
1211
1212	var splitter = opt.splitter \|\| requireResponseHandler('ListLogSummary').SPLITTER;
1213	var format = opt.format \|\| {
1214	hash: '%H',
1215	date: '%ai',
1216	message: '%s',
1217	refs: '%D',
1218	body: opt.multiLine ? '%B' : '%b',
1219	author_name: '%aN',
1220	author_email: '%ae'
1221	};
1222	var rangeOperator = (opt.symmetric !== false) ? '...' : '..';
1223
1224	var fields = Object.keys(format);
1225	var formatstr = fields.map(function (k) {
1226	return format[k];
1227	}).join(splitter);
1228	var suffix = [];
1229	var command = ["log", "--pretty=format:"
1230	+ requireResponseHandler('ListLogSummary').START_BOUNDARY
1231	+ formatstr
1232	+ requireResponseHandler('ListLogSummary').COMMIT_BOUNDARY
1233	];
1234
1235	if (Array.isArray(opt)) {
1236	command = command.concat(opt);
1237	opt = {};
1238	}
1239	else if (typeof arguments[0] === "string" \|\| typeof arguments[1] === "string") {
1240	this._getLog('warn',
1241	'Git#log: supplying to or from as strings is now deprecated, switch to an options configuration object');
1242	opt = {
1243	from: arguments[0],
1244	to: arguments[1]
1245	};
1246	}
1247
1248	if (opt.n \|\| opt['max-count']) {
1249	command.push("--max-count=" + (opt.n \|\| opt['max-count']));
1250	}
1251
1252	if (opt.from && opt.to) {
1253	command.push(opt.from + rangeOperator + opt.to);
1254	}
1255
1256	if (opt.file) {
1257	suffix.push("--follow", options.file);
1258	}
1259
1260	'splitter n max-count file from to --pretty format symmetric multiLine'.split(' ').forEach(function (key) {
1261	delete opt[key];
1262	});
1263
1264	Git._appendOptions(command, opt);
1265
1266	return this._run(
1267	command.concat(suffix),
1268	Git._responseHandler(handler, 'ListLogSummary', [splitter, fields])
1269	);
1270	};
1271
1272	/**
1273	* Clears the queue of pending commands and returns the wrapper instance for chaining.
1274	*
1275	* @returns {Git}
1276	*/
1277	Git.prototype.clearQueue = function () {
1278	this._runCache.length = 0;
1279	return this;
1280	};
1281
1282	/**
1283	* Check if a pathname or pathnames are excluded by .gitignore
1284	*
1285	* @param {string\|string[]} pathnames
1286	* @param {Function} [then]
1287	*/
1288	Git.prototype.checkIgnore = function (pathnames, then) {
1289	var handler = Git.trailingFunctionArgument(arguments);
1290	var command = ["check-ignore"];
1291
1292	if (handler !== pathnames) {
1293	command = command.concat(pathnames);
1294	}
1295
1296	return this._run(command, function (err, data) {
1297	handler && handler(err, !err && this._parseCheckIgnore(data));
1298	});
1299	};
1300
1301	/**
1302	* Validates that the current repo is a Git repo.
1303	*
1304	* @param {Function} [then]
1305	*/
1306	Git.prototype.checkIsRepo = function (then) {
1307	function onError (exitCode, stdErr, done, fail) {
1308	if (exitCode === 128 && /(Not a git repository\|Kein Git-Repository)/i.test(stdErr)) {
1309	return done(false);
1310	}
1311
1312	fail(stdErr);
1313	}
1314
1315	function handler (err, isRepo) {
1316	then && then(err, String(isRepo).trim() === 'true');
1317	}
1318
1319	return this._run(['rev-parse', '--is-inside-work-tree'], handler, {onError: onError});
1320	};
1321
1322	Git.prototype._rm = function (_files, options, then) {
1323	var files = [].concat(_files);
1324	var args = ['rm', options];
1325	args.push.apply(args, files);
1326
1327	return this._run(args, function (err) {
1328	then && then(err);
1329	});
1330	};
1331
1332	Git.prototype._parseCheckout = function (checkout) {
1333	// TODO
1334	};
1335
1336	/**
1337	* Parser for the `check-ignore` command - returns each
1338	* @param {string} [files]
1339	* @returns {string[]}
1340	*/
1341	Git.prototype._parseCheckIgnore = function (files) {
1342	return files.split(/\n/g).filter(Boolean).map(function (file) {
1343	return file.trim()
1344	});
1345	};
1346
1347	/**
1348	* Schedules the supplied command to be run, the command should not include the name of the git binary and should
1349	* be an array of strings passed as the arguments to the git binary.
1350	*
1351	* @param {string[]} command
1352	* @param {Function} then
1353	* @param {Object} [opt]
1354	* @param {boolean} [opt.concatStdErr=false] Optionally concatenate stderr output into the stdout
1355	* @param {boolean} [opt.format="utf-8"] The format to use when reading the content of stdout
1356	* @param {Function} [opt.onError] Optional error handler for this command - can be used to allow non-clean exits
1357	* without killing the remaining stack of commands
1358	* @param {number} [opt.onError.exitCode]
1359	* @param {string} [opt.onError.stdErr]
1360	*
1361	* @returns {Git}
1362	*/
1363	Git.prototype._run = function (command, then, opt) {
1364	if (typeof command === "string") {
1365	command = command.split(" ");
1366	}
1367	this._runCache.push([command, then, opt \|\| {}]);
1368	this._schedule();
1369
1370	return this;
1371	};
1372
1373	Git.prototype._schedule = function () {
1374	if (!this._childProcess && this._runCache.length) {
1375	var git = this;
1376	var Buffer = git.Buffer;
1377	var task = git._runCache.shift();
1378
1379	var command = task[0];
1380	var then = task[1];
1381	var options = task[2];
1382
1383	debug(command);
1384
1385	var result = deferred();
1386
1387	var attempted = false;
1388	var attemptClose = function attemptClose (e) {
1389
1390	// closing when there is content, terminate immediately
1391	if (attempted \|\| stdErr.length \|\| stdOut.length) {
1392	result.resolve(e);
1393	attempted = true;
1394	}
1395
1396	// first attempt at closing but no content yet, wait briefly for the close/exit that may follow
1397	if (!attempted) {
1398	attempted = true;
1399	setTimeout(attemptClose.bind(this, e), 50);
1400	}
1401
1402	};
1403
1404	var stdOut = [];
1405	var stdErr = [];
1406	var spawned = git.ChildProcess.spawn(git._command, command.slice(0), {
1407	cwd: git._baseDir,
1408	env: git._env,
1409	windowsHide: true
1410	});
1411
1412	spawned.stdout.on('data', function (buffer) {
1413	stdOut.push(buffer);
1414	});
1415
1416	spawned.stderr.on('data', function (buffer) {
1417	stdErr.push(buffer);
1418	});
1419
1420	spawned.on('error', function (err) {
1421	stdErr.push(Buffer.from(err.stack, 'ascii'));
1422	});
1423
1424	spawned.on('close', attemptClose);
1425	spawned.on('exit', attemptClose);
1426
1427	result.promise.then(function (exitCode) {
1428	function done (output) {
1429	then.call(git, null, output);
1430	}
1431
1432	function fail (error) {
1433	Git.fail(git, error, then);
1434	}
1435
1436	delete git._childProcess;
1437
1438	if (exitCode && stdErr.length && options.onError) {
1439	options.onError(exitCode, Buffer.concat(stdErr).toString('utf-8'), done, fail);
1440	}
1441	else if (exitCode && stdErr.length) {
1442	fail(Buffer.concat(stdErr).toString('utf-8'));
1443	}
1444	else {
1445	if (options.concatStdErr) {
1446	[].push.apply(stdOut, stdErr);
1447	}
1448
1449	var stdOutput = Buffer.concat(stdOut);
1450	if (options.format !== 'buffer') {
1451	stdOutput = stdOutput.toString(options.format \|\| 'utf-8');
1452	}
1453
1454	done(stdOutput);
1455	}
1456
1457	process.nextTick(git._schedule.bind(git));
1458	});
1459
1460	git._childProcess = spawned;
1461
1462	if (git._outputHandler) {
1463	git._outputHandler(command[0], git._childProcess.stdout, git._childProcess.stderr);
1464	}
1465	}
1466	};
1467
1468	/**
1469	* Handles an exception in the processing of a command.
1470	*/
1471	Git.fail = function (git, error, handler) {
1472	git._getLog('error', error);
1473	git._runCache.length = 0;
1474	if (typeof handler === 'function') {
1475	handler.call(git, error, null);
1476	}
1477	};
1478
1479	/**
1480	* Given any number of arguments, returns the last argument if it is a function, otherwise returns null.
1481	* @returns {Function\|null}
1482	*/
1483	Git.trailingFunctionArgument = function (args) {
1484	var trailing = args[args.length - 1];
1485	return (typeof trailing === "function") ? trailing : null;
1486	};
1487
1488	/**
1489	* Given any number of arguments, returns the trailing options argument, ignoring a trailing function argument
1490	* if there is one. When not found, the return value is null.
1491	* @returns {Object\|null}
1492	*/
1493	Git.trailingOptionsArgument = function (args) {
1494	var options = args[(args.length - (Git.trailingFunctionArgument(args) ? 2 : 1))];
1495	return Object.prototype.toString.call(options) === '[object Object]' ? options : null;
1496	};
1497
1498	/**
1499	* Given any number of arguments, returns the trailing options array argument, ignoring a trailing function argument
1500	* if there is one. When not found, the return value is an empty array.
1501	* @returns {Array}
1502	*/
1503	Git.trailingArrayArgument = function (args) {
1504	var options = args[(args.length - (Git.trailingFunctionArgument(args) ? 2 : 1))];
1505	return Object.prototype.toString.call(options) === '[object Array]' ? options : [];
1506	};
1507
1508	/**
1509	* Mutates the supplied command array by merging in properties in the options object. When the
1510	* value of the item in the options object is a string it will be concatenated to the key as
1511	* a single `name=value` item, otherwise just the name will be used.
1512	*
1513	* @param {string[]} command
1514	* @param {Object} options
1515	* @private
1516	*/
1517	Git._appendOptions = function (command, options) {
1518	if (options === null) {
1519	return;
1520	}
1521
1522	Object.keys(options).forEach(function (key) {
1523	var value = options[key];
1524	if (typeof value === 'string') {
1525	command.push(key + '=' + value);
1526	}
1527	else {
1528	command.push(key);
1529	}
1530	});
1531	};
1532
1533	/**
1534	* Given the type of response and the callback to receive the parsed response,
1535	* uses the correct parser and calls back the callback.
1536	*
1537	* @param {Function} callback
1538	* @param {string} [type]
1539	* @param {Object[]} [args]
1540	*
1541	* @private
1542	*/
1543	Git._responseHandler = function (callback, type, args) {
1544	return function (error, data) {
1545	if (typeof callback !== 'function') {
1546	return;
1547	}
1548
1549	if (error) {
1550	return callback(error, null);
1551	}
1552
1553	if (!type) {
1554	return callback(null, data);
1555	}
1556
1557	var handler = requireResponseHandler(type);
1558	var result = handler.parse.apply(handler, [data].concat(args === undefined ? [] : args));
1559
1560	callback(null, result);
1561	};
1562
1563	};
1564
1565	/**
1566	* Marks the git instance as having had a fatal exception by clearing the pending queue of tasks and
1567	* logging to the console.
1568	*
1569	* @param git
1570	* @param error
1571	* @param callback
1572	*/
1573	Git.exception = function (git, error, callback) {
1574	git._runCache.length = 0;
1575	if (typeof callback === 'function') {
1576	callback(error instanceof Error ? error : new Error(error));
1577	}
1578
1579	git._getLog('error', error);
1580	};
1581
1582	module.exports = Git;
1583
1584	/**
1585	* Requires and returns a response handler based on its named type
1586	* @param {string} type
1587	*/
1588	function requireResponseHandler (type) {
1589	return responses[type];
1590	}
1591
1592	}());

node_modules/simple-git/src/index.js+0−14

@@ -1,14 +0,0 @@
1
2	var Git = require('./git');
3
4	module.exports = function (baseDir) {
5
6	var dependencies = require('./util/dependencies');
7
8	if (baseDir && !dependencies.exists(baseDir, dependencies.exists.FOLDER)) {
9	throw new Error("Cannot use simple-git on a directory that does not exist.");
10	}
11
12	return new Git(baseDir \|\| process.cwd(), dependencies.childProcess(), dependencies.buffer());
13	};
14

node_modules/simple-git/src/responses/BranchDeleteSummary.js+0−26

@@ -1,26 +0,0 @@
1
2	module.exports = BranchDeletion;
3
4	function BranchDeletion (branch, hash) {
5	this.branch = branch;
6	this.hash = hash;
7	this.success = hash !== null;
8	}
9
10	BranchDeletion.deleteSuccessRegex = /(\S+)\s+$\S+\s([^$]+)\)/;
11	BranchDeletion.deleteErrorRegex = /^error[^']+'([^']+)'/;
12
13	BranchDeletion.parse = function (data, asArray) {
14	var result;
15	var branchDeletions = data.trim().split('\n').map(function (line) {
16	if (result = BranchDeletion.deleteSuccessRegex.exec(line)) {
17	return new BranchDeletion(result[1], result[2]);
18	}
19	else if (result = BranchDeletion.deleteErrorRegex.exec(line)) {
20	return new BranchDeletion(result[1], null);
21	}
22	})
23	.filter(Boolean);
24
25	return asArray ? branchDeletions : branchDeletions.pop();
26	};

node_modules/simple-git/src/responses/BranchSummary.js+0−52

@@ -1,52 +0,0 @@
1
2	module.exports = BranchSummary;
3
4	function BranchSummary () {
5	this.detached = false;
6	this.current = '';
7	this.all = [];
8	this.branches = {};
9	}
10
11	BranchSummary.prototype.push = function (current, detached, name, commit, label) {
12	if (current) {
13	this.detached = detached;
14	this.current = name;
15	}
16	this.all.push(name);
17	this.branches[name] = {
18	current: current,
19	name: name,
20	commit: commit,
21	label: label
22	};
23	};
24
25	BranchSummary.detachedRegex = /^(\?\s+)$(?:HEAD )?detached (?:from\|at) (\S+)$\s+([a-z0-9]+)\s(.)$/;
26	BranchSummary.branchRegex = /^(\?\s+)(\S+)\s+([a-z0-9]+)\s(.)$/;
27
28	BranchSummary.parse = function (commit) {
29	var branchSummary = new BranchSummary();
30
31	commit.split('\n')
32	.forEach(function (line) {
33	var detached = true;
34	var branch = BranchSummary.detachedRegex.exec(line);
35	if (!branch) {
36	detached = false;
37	branch = BranchSummary.branchRegex.exec(line);
38	}
39
40	if (branch) {
41	branchSummary.push(
42	branch[1].charAt(0) === '*',
43	detached,
44	branch[2],
45	branch[3],
46	branch[4]
47	);
48	}
49	});
50
51	return branchSummary;
52	};

node_modules/simple-git/src/responses/CommitSummary.js+0−60

@@ -1,60 +0,0 @@
1
2	module.exports = CommitSummary;
3
4	function CommitSummary () {
5	this.branch = '';
6	this.commit = '';
7	this.summary = {
8	changes: 0,
9	insertions: 0,
10	deletions: 0
11	};
12	this.author = null;
13	}
14
15	var COMMIT_BRANCH_MESSAGE_REGEX = /\[([^\s]+) ([^\]]+)/;
16	var COMMIT_AUTHOR_MESSAGE_REGEX = /\s*Author:\s(.+)/i;
17
18	function setBranchFromCommit (commitSummary, commitData) {
19	if (commitData) {
20	commitSummary.branch = commitData[1];
21	commitSummary.commit = commitData[2];
22	}
23	}
24
25	function setSummaryFromCommit (commitSummary, commitData) {
26	if (commitSummary.branch && commitData) {
27	commitSummary.summary.changes = commitData[1] \|\| 0;
28	commitSummary.summary.insertions = commitData[2] \|\| 0;
29	commitSummary.summary.deletions = commitData[3] \|\| 0;
30	}
31	}
32
33	function setAuthorFromCommit (commitSummary, commitData) {
34	var parts = commitData[1].split('<');
35	var email = parts.pop();
36
37	if (email.indexOf('@') <= 0) {
38	return;
39	}
40
41	commitSummary.author = {
42	email: email.substr(0, email.length - 1),
43	name: parts.join('<').trim()
44	};
45	}
46
47	CommitSummary.parse = function (commit) {
48	var lines = commit.trim().split('\n');
49	var commitSummary = new CommitSummary();
50
51	setBranchFromCommit(commitSummary, COMMIT_BRANCH_MESSAGE_REGEX.exec(lines.shift()));
52
53	if (COMMIT_AUTHOR_MESSAGE_REGEX.test(lines[0])) {
54	setAuthorFromCommit(commitSummary, COMMIT_AUTHOR_MESSAGE_REGEX.exec(lines.shift()));
55	}
56
57	setSummaryFromCommit(commitSummary, /(\d+)[^,](?:,\s(\d+)[^,])?(?:,\s(\d+))?/g.exec(lines.shift()));
58
59	return commitSummary;
60	};

node_modules/simple-git/src/responses/DiffSummary.js+0−92

@@ -1,92 +0,0 @@
1
2	module.exports = DiffSummary;
3
4	/**
5	* The DiffSummary is returned as a response to getting `git().status()`
6	*
7	* @constructor
8	*/
9	function DiffSummary () {
10	this.files = [];
11	this.insertions = 0;
12	this.deletions = 0;
13	this.changed = 0;
14	}
15
16	/**
17	* Number of lines added
18	* @type {number}
19	*/
20	DiffSummary.prototype.insertions = 0;
21
22	/**
23	* Number of lines deleted
24	* @type {number}
25	*/
26	DiffSummary.prototype.deletions = 0;
27
28	/**
29	* Number of files changed
30	* @type {number}
31	*/
32	DiffSummary.prototype.changed = 0;
33
34	DiffSummary.parse = function (text) {
35	var line, handler;
36
37	var lines = text.trim().split('\n');
38	var status = new DiffSummary();
39
40	var summary = lines.pop();
41	if (summary) {
42	summary.trim().split(', ').forEach(function (text) {
43	var summary = /(\d+)\s([a-z]+)/.exec(text);
44	if (!summary) {
45	return;
46	}
47
48	if (/files?/.test(summary[2])) {
49	status.changed = parseInt(summary[1], 10);
50	}
51	else {
52	status[summary[2].replace(/s$/, '') + 's'] = parseInt(summary[1], 10);
53	}
54	});
55	}
56
57	while (line = lines.shift()) {
58	textFileChange(line, status.files) \|\| binaryFileChange(line, status.files);
59	}
60
61	return status;
62	};
63
64	function textFileChange (line, files) {
65	line = line.trim().match(/^(.+)\s+\\|\s+(\d+)(\s+[+\-]+)?$/);
66
67	if (line) {
68	var alterations = (line[3] \|\| '').trim();
69	files.push({
70	file: line[1].trim(),
71	changes: parseInt(line[2], 10),
72	insertions: alterations.replace(/-/g, '').length,
73	deletions: alterations.replace(/\+/g, '').length,
74	binary: false
75	});
76
77	return true;
78	}
79	}
80
81	function binaryFileChange (line, files) {
82	line = line.match(/^(.+) \\|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)$/);
83	if (line) {
84	files.push({
85	file: line[1].trim(),
86	before: +line[2],
87	after: +line[3],
88	binary: true
89	});
90	return true;
91	}
92	}

node_modules/simple-git/src/responses/FetchSummary.js+0−55

@@ -1,55 +0,0 @@
1	'use strict';
2
3	function FetchSummary (raw) {
4	this.raw = raw;
5
6	this.remote = null;
7	this.branches = [];
8	this.tags = [];
9	}
10
11	FetchSummary.parsers = [
12	[
13	/From (.+)$/, function (fetchSummary, matches) {
14	fetchSummary.remote = matches[0];
15	}
16	],
17	[
18	/\* \[new branch\]\s+(\S+)\s*\-> (.+)$/, function (fetchSummary, matches) {
19	fetchSummary.branches.push({
20	name: matches[0],
21	tracking: matches[1]
22	});
23	}
24	],
25	[
26	/\* \[new tag\]\s+(\S+)\s*\-> (.+)$/, function (fetchSummary, matches) {
27	fetchSummary.tags.push({
28	name: matches[0],
29	tracking: matches[1]
30	});
31	}
32	]
33	];
34
35	FetchSummary.parse = function (data) {
36	var fetchSummary = new FetchSummary(data);
37
38	String(data)
39	.trim()
40	.split('\n')
41	.forEach(function (line) {
42	var original = line.trim();
43	FetchSummary.parsers.some(function (parser) {
44	var parsed = parser[0].exec(original);
45	if (parsed) {
46	parser[1](fetchSummary, parsed.slice(1));
47	return true;
48	}
49	});
50	});
51
52	return fetchSummary;
53	};
54
55	module.exports = FetchSummary;

node_modules/simple-git/src/responses/FileStatusSummary.js+0−22

@@ -1,22 +0,0 @@
1	'use strict';
2
3	function FileStatusSummary (path, index, working_dir) {
4	this.path = path;
5	this.index = index;
6	this.working_dir = working_dir;
7
8	if ('R' === index + working_dir) {
9	var detail = FileStatusSummary.fromPathRegex.exec(path) \|\| [null, path, path];
10	this.from = detail[1];
11	this.path = detail[2];
12	}
13	}
14
15	FileStatusSummary.fromPathRegex = /^(.+) -> (.+)$/;
16
17	FileStatusSummary.prototype = {
18	path: '',
19	from: ''
20	};
21
22	module.exports = FileStatusSummary;

node_modules/simple-git/src/responses/ListLogSummary.js+0−72

@@ -1,72 +0,0 @@
1
2	module.exports = ListLogSummary;
3
4	var DiffSummary = require('./DiffSummary');
5
6	/**
7	* The ListLogSummary is returned as a response to getting `git().log()` or `git().stashList()`
8	*
9	* @constructor
10	*/
11	function ListLogSummary (all) {
12	this.all = all;
13	this.latest = all.length && all[0] \|\| null;
14	this.total = all.length;
15	}
16
17	/**
18	* Detail for each of the log lines
19	* @type {ListLogLine[]}
20	*/
21	ListLogSummary.prototype.all = null;
22
23	/**
24	* Most recent entry in the log
25	* @type {ListLogLine}
26	*/
27	ListLogSummary.prototype.latest = null;
28
29	/**
30	* Number of items in the log
31	* @type {number}
32	*/
33	ListLogSummary.prototype.total = 0;
34
35	function ListLogLine (line, fields) {
36	for (var k = 0; k < fields.length; k++) {
37	this[fields[k]] = line[k] \|\| '';
38	}
39	}
40
41	/**
42	* When the log was generated with a summary, the `diff` property contains as much detail
43	* as was provided in the log (whether generated with `--stat` or `--shortstat`.
44	* @type {DiffSummary}
45	*/
46	ListLogLine.prototype.diff = null;
47
48	ListLogSummary.START_BOUNDARY = 'òòòòòò ';
49
50	ListLogSummary.COMMIT_BOUNDARY = ' òò';
51
52	ListLogSummary.SPLITTER = ' ò ';
53
54	ListLogSummary.parse = function (text, splitter, fields) {
55	fields = fields \|\| ['hash', 'date', 'message', 'refs', 'author_name', 'author_email'];
56	return new ListLogSummary(
57	text
58	.trim()
59	.split(ListLogSummary.START_BOUNDARY)
60	.filter(function(item) { return !!item.trim(); })
61	.map(function (item) {
62	var lineDetail = item.trim().split(ListLogSummary.COMMIT_BOUNDARY);
63	var listLogLine = new ListLogLine(lineDetail[0].trim().split(splitter), fields);
64
65	if (lineDetail.length > 1 && !!lineDetail[1].trim()) {
66	listLogLine.diff = DiffSummary.parse(lineDetail[1]);
67	}
68
69	return listLogLine;
70	})
71	);
72	};

node_modules/simple-git/src/responses/MergeSummary.js+0−103

@@ -1,103 +0,0 @@
1	module.exports = MergeSummary;
2	module.exports.MergeConflict = MergeConflict;
3
4	var PullSummary = require('./PullSummary');
5
6	function MergeConflict (reason, file, meta) {
7	this.reason = reason;
8	this.file = file;
9	if (meta) {
10	this.meta = meta;
11	}
12	}
13
14	MergeConflict.prototype.meta = null;
15
16	MergeConflict.prototype.toString = function () {
17	return this.file + ':' + this.reason;
18	};
19
20	function MergeSummary () {
21	PullSummary.call(this);
22
23	this.conflicts = [];
24	this.merges = [];
25	}
26
27	MergeSummary.prototype = Object.create(PullSummary.prototype);
28
29	MergeSummary.prototype.result = 'success';
30
31	MergeSummary.prototype.toString = function () {
32	if (this.conflicts.length) {
33	return 'CONFLICTS: ' + this.conflicts.join(', ');
34	}
35	return 'OK';
36	};
37
38	Object.defineProperty(MergeSummary.prototype, 'failed', {
39	get: function () {
40	return this.conflicts.length > 0;
41	}
42	});
43
44	MergeSummary.parsers = [
45	{
46	test: /^Auto-merging\s+(.+)$/,
47	handle: function (result, mergeSummary) {
48	mergeSummary.merges.push(result[1]);
49	}
50	},
51	{
52	// Parser for standard merge conflicts
53	test: /^CONFLICT\s+$(.+)$: Merge conflict in (.+)$/,
54	handle: function (result, mergeSummary) {
55	mergeSummary.conflicts.push(new MergeConflict(result[1], result[2]));
56	}
57	},
58	{
59	// Parser for modify/delete merge conflicts (modified by us/them, deleted by them/us)
60	test: /^CONFLICT\s+$(.+\/delete)$: (.+) deleted in (.+) and/,
61	handle: function (result, mergeSummary) {
62	mergeSummary.conflicts.push(
63	new MergeConflict(result[1], result[2], {deleteRef: result[3]})
64	);
65	}
66	},
67	{
68	// Catch-all parser for unknown/unparsed conflicts
69	test: /^CONFLICT\s+$(.+)$:/,
70	handle: function (result, mergeSummary) {
71	mergeSummary.conflicts.push(new MergeConflict(result[1], null));
72	}
73	},
74	{
75	test: /^Automatic merge failed;\s+(.+)$/,
76	handle: function (result, mergeSummary) {
77	mergeSummary.reason = mergeSummary.result = result[1];
78	}
79	}
80	];
81
82	MergeSummary.parse = function (output) {
83	let mergeSummary = new MergeSummary();
84
85	output.trim().split('\n').forEach(function (line) {
86	for (var i = 0, iMax = MergeSummary.parsers.length; i < iMax; i++) {
87	let parser = MergeSummary.parsers[i];
88
89	var result = parser.test.exec(line);
90	if (result) {
91	parser.handle(result, mergeSummary);
92	break;
93	}
94	}
95	});
96
97	let pullSummary = PullSummary.parse(output);
98	if (pullSummary.summary.changes) {
99	Object.assign(mergeSummary, pullSummary);
100	}
101
102	return mergeSummary;
103	};

node_modules/simple-git/src/responses/MoveSummary.js+0−32

@@ -1,32 +0,0 @@
1
2	module.exports = MoveSummary;
3
4	/**
5	* The MoveSummary is returned as a response to getting `git().status()`
6	*
7	* @constructor
8	*/
9	function MoveSummary () {
10	this.moves = [];
11	this.sources = {};
12	}
13
14	MoveSummary.SUMMARY_REGEX = /^Renaming (.+) to (.+)$/;
15
16	MoveSummary.parse = function (text) {
17	var lines = text.split('\n');
18	var summary = new MoveSummary();
19
20	for (var i = 0, iMax = lines.length, line; i < iMax; i++) {
21	line = MoveSummary.SUMMARY_REGEX.exec(lines[i].trim());
22
23	if (line) {
24	summary.moves.push({
25	from: line[1],
26	to: line[2]
27	});
28	}
29	}
30
31	return summary;
32	};

node_modules/simple-git/src/responses/PullSummary.js+0−137

@@ -1,137 +0,0 @@
1
2	module.exports = PullSummary;
3
4	/**
5	* The PullSummary is returned as a response to getting `git().pull()`
6	*
7	* @constructor
8	*/
9	function PullSummary () {
10	this.files = [];
11	this.insertions = {};
12	this.deletions = {};
13
14	this.summary = {
15	changes: 0,
16	insertions: 0,
17	deletions: 0
18	};
19
20	this.created = [];
21	this.deleted = [];
22	}
23
24	/**
25	* Array of files that were created
26	* @type {string[]}
27	*/
28	PullSummary.prototype.created = null;
29
30	/**
31	* Array of files that were deleted
32	* @type {string[]}
33	*/
34	PullSummary.prototype.deleted = null;
35
36	/**
37	* The array of file paths/names that have been modified in any part of the pulled content
38	* @type {string[]}
39	*/
40	PullSummary.prototype.files = null;
41
42	/**
43	* A map of file path to number to show the number of insertions per file.
44	* @type {Object}
45	*/
46	PullSummary.prototype.insertions = null;
47
48	/**
49	* A map of file path to number to show the number of deletions per file.
50	* @type {Object}
51	*/
52	PullSummary.prototype.deletions = null;
53
54	/**
55	* Overall summary of changes/insertions/deletions and the number associated with each
56	* across all content that was pulled.
57	* @type {Object}
58	*/
59	PullSummary.prototype.summary = null;
60
61	PullSummary.FILE_UPDATE_REGEX = /^\s(.+?)\s+\\|\s+\d+\s(\+)(-)/;
62	PullSummary.SUMMARY_REGEX = /(\d+)\D+((\d+)\D+$\+$)?(\D+(\d+)\D+$-$)?/;
63	PullSummary.ACTION_REGEX = /(create\|delete) mode \d+ (.+)/;
64
65	PullSummary.parse = function (text) {
66	var pullSummary = new PullSummary;
67	var lines = text.split('\n');
68
69	while (lines.length) {
70	var line = lines.shift().trim();
71	if (!line) {
72	continue;
73	}
74
75	update(pullSummary, line) \|\| summary(pullSummary, line) \|\| action(pullSummary, line);
76	}
77
78	return pullSummary;
79	};
80
81	function update (pullSummary, line) {
82
83	var update = PullSummary.FILE_UPDATE_REGEX.exec(line);
84	if (!update) {
85	return false;
86	}
87
88	pullSummary.files.push(update[1]);
89
90	var insertions = update[2].length;
91	if (insertions) {
92	pullSummary.insertions[update[1]] = insertions;
93	}
94
95	var deletions = update[3].length;
96	if (deletions) {
97	pullSummary.deletions[update[1]] = deletions;
98	}
99
100	return true;
101	}
102
103	function summary (pullSummary, line) {
104	if (!pullSummary.files.length) {
105	return false;
106	}
107
108	var update = PullSummary.SUMMARY_REGEX.exec(line);
109	if (!update \|\| (update[3] === undefined && update[5] === undefined)) {
110	return false;
111	}
112
113	pullSummary.summary.changes = +update[1] \|\| 0;
114	pullSummary.summary.insertions = +update[3] \|\| 0;
115	pullSummary.summary.deletions = +update[5] \|\| 0;
116
117	return true;
118	}
119
120	function action (pullSummary, line) {
121
122	var match = PullSummary.ACTION_REGEX.exec(line);
123	if (!match) {
124	return false;
125	}
126
127	var file = match[2];
128
129	if (pullSummary.files.indexOf(file) < 0) {
130	pullSummary.files.push(file);
131	}
132
133	var container = (match[1] === 'create') ? pullSummary.created : pullSummary.deleted;
134	container.push(file);
135
136	return true;
137	}

node_modules/simple-git/src/responses/StatusSummary.js+0−188

@@ -1,188 +0,0 @@
1
2
3
4	var FileStatusSummary = require('./FileStatusSummary');
5
6	module.exports = StatusSummary;
7
8	/**
9	* The StatusSummary is returned as a response to getting `git().status()`
10	*
11	* @constructor
12	*/
13	function StatusSummary () {
14	this.not_added = [];
15	this.conflicted = [];
16	this.created = [];
17	this.deleted = [];
18	this.modified = [];
19	this.renamed = [];
20	this.files = [];
21	this.staged = [];
22	}
23
24
25	/**
26	* Number of commits ahead of the tracked branch
27	* @type {number}
28	*/
29	StatusSummary.prototype.ahead = 0;
30
31	/**
32	* Number of commits behind the tracked branch
33	* @type {number}
34	*/
35	StatusSummary.prototype.behind = 0;
36
37	/**
38	* Name of the current branch
39	* @type {null}
40	*/
41	StatusSummary.prototype.current = null;
42
43	/**
44	* Name of the branch being tracked
45	* @type {string}
46	*/
47	StatusSummary.prototype.tracking = null;
48
49	/**
50	* All files represented as an array of objects containing the `path` and status in `index` and
51	* in the `working_dir`.
52	*
53	* @type {Array}
54	*/
55	StatusSummary.prototype.files = null;
56
57	/**
58	* Gets whether this StatusSummary represents a clean working branch.
59	*
60	* @return {boolean}
61	*/
62	StatusSummary.prototype.isClean = function () {
63	return 0 === Object.keys(this).filter(function (name) {
64	return Array.isArray(this[name]) && this[name].length;
65	}, this).length;
66	};
67
68	StatusSummary.parsers = {
69	'##': function (line, status) {
70	var aheadReg = /ahead (\d+)/;
71	var behindReg = /behind (\d+)/;
72	var currentReg = /^(.+?(?=(?:\.{3}\|\s\|$)))/;
73	var trackingReg = /\.{3}(\S*)/;
74	var regexResult;
75
76	regexResult = aheadReg.exec(line);
77	status.ahead = regexResult && +regexResult[1] \|\| 0;
78
79	regexResult = behindReg.exec(line);
80	status.behind = regexResult && +regexResult[1] \|\| 0;
81
82	regexResult = currentReg.exec(line);
83	status.current = regexResult && regexResult[1];
84
85	regexResult = trackingReg.exec(line);
86	status.tracking = regexResult && regexResult[1];
87	},
88
89	'??': function (line, status) {
90	status.not_added.push(line);
91	},
92
93	A: function (line, status) {
94	status.created.push(line);
95	},
96
97	AM: function (line, status) {
98	status.created.push(line);
99	},
100
101	D: function (line, status) {
102	status.deleted.push(line);
103	},
104
105	M: function (line, status, indexState) {
106	status.modified.push(line);
107
108	if (indexState === 'M') {
109	status.staged.push(line);
110	}
111	},
112
113	R: function (line, status) {
114	var detail = /^(.+) -> (.+)$/.exec(line) \|\| [null, line, line];
115
116	status.renamed.push({
117	from: detail[1],
118	to: detail[2]
119	});
120	},
121
122	UU: function (line, status) {
123	status.conflicted.push(line);
124	}
125	};
126
127	StatusSummary.parsers.MM = StatusSummary.parsers.M;
128
129	/* Map all unmerged status code combinations to UU to mark as conflicted */
130	StatusSummary.parsers.AA = StatusSummary.parsers.UU;
131	StatusSummary.parsers.UD = StatusSummary.parsers.UU;
132	StatusSummary.parsers.DU = StatusSummary.parsers.UU;
133	StatusSummary.parsers.DD = StatusSummary.parsers.UU;
134	StatusSummary.parsers.AU = StatusSummary.parsers.UU;
135	StatusSummary.parsers.UA = StatusSummary.parsers.UU;
136
137	StatusSummary.parse = function (text) {
138	var file;
139	var lines = text.trim().split('\n');
140	var status = new StatusSummary();
141
142	for (var i = 0, l = lines.length; i < l; i++) {
143	file = splitLine(lines[i]);
144
145	if (!file) {
146	continue;
147	}
148
149	if (file.handler) {
150	file.handler(file.path, status, file.index, file.workingDir);
151	}
152
153	if (file.code !== '##') {
154	status.files.push(new FileStatusSummary(file.path, file.index, file.workingDir));
155	}
156	}
157
158	return status;
159	};
160
161
162	function splitLine (lineStr) {
163	var line = lineStr.trim().match(/(..?)(\s+)(.*)/);
164	if (!line \|\| !line[1].trim()) {
165	line = lineStr.trim().match(/(..?)\s+(.*)/);
166	}
167
168	if (!line) {
169	return;
170	}
171
172	var code = line[1];
173	if (line[2].length > 1) {
174	code += ' ';
175	}
176	if (code.length === 1 && line[2].length === 1) {
177	code = ' ' + code;
178	}
179
180	return {
181	raw: code,
182	code: code.trim(),
183	index: code.charAt(0),
184	workingDir: code.charAt(1),
185	handler: StatusSummary.parsers[code.trim()],
186	path: line[3]
187	};
188	}

node_modules/simple-git/src/responses/TagList.js+0−50

@@ -1,50 +0,0 @@
1
2	module.exports = TagList;
3
4	function TagList (tagList, latest) {
5	this.latest = latest;
6	this.all = tagList
7	}
8
9	TagList.parse = function (data, customSort) {
10	var number = function (input) {
11	if (typeof input === 'string') {
12	return parseInt(input.replace(/^\D+/g, ''), 10) \|\| 0;
13	}
14
15	return 0;
16	};
17
18	var tags = data
19	.trim()
20	.split('\n')
21	.map(function (item) { return item.trim(); })
22	.filter(Boolean);
23
24	if (!customSort) {
25	tags.sort(function (tagA, tagB) {
26	var partsA = tagA.split('.');
27	var partsB = tagB.split('.');
28
29	if (partsA.length === 1 \|\| partsB.length === 1) {
30	return tagA - tagB > 0 ? 1 : -1;
31	}
32
33	for (var i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) {
34	var a = number(partsA[i]);
35	var b = number(partsB[i]);
36
37	var diff = a - b;
38	if (diff) {
39	return diff > 0 ? 1 : -1;
40	}
41	}
42
43	return 0;
44	});
45	}
46
47	var latest = customSort ? tags[0] : tags.filter(function (tag) { return tag.indexOf('.') >= 0; }).pop();
48
49	return new TagList(tags, latest);
50	};

node_modules/simple-git/src/responses/index.js+0−15

@@ -1,15 +0,0 @@
1
2	module.exports = {
3	BranchDeleteSummary: require('./BranchDeleteSummary'),
4	BranchSummary: require('./BranchSummary'),
5	CommitSummary: require('./CommitSummary'),
6	DiffSummary: require('./DiffSummary'),
7	FetchSummary: require('./FetchSummary'),
8	FileStatusSummary: require('./FileStatusSummary'),
9	ListLogSummary: require('./ListLogSummary'),
10	MergeSummary: require('./MergeSummary'),
11	MoveSummary: require('./MoveSummary'),
12	PullSummary: require('./PullSummary'),
13	StatusSummary: require('./StatusSummary'),
14	TagList: require('./TagList'),
15	};

node_modules/simple-git/src/util/deferred.js+0−10

@@ -1,10 +0,0 @@
1
2	module.exports = function deferred () {
3	var d = {};
4	d.promise = new Promise(function (resolve, reject) {
5	d.resolve = resolve;
6	d.reject = reject
7	});
8
9	return d;
10	};

node_modules/simple-git/src/util/dependencies.js+0−12

@@ -1,12 +0,0 @@
1	/**
2	* Exports the utilities `simple-git` depends upon to allow for mocking during a test
3	*/
4	module.exports = {
5
6	buffer: function () { return require('buffer').Buffer; },
7
8	childProcess: function () { return require('child_process'); },
9
10	exists: require('./exists')
11
12	};

node_modules/simple-git/src/util/exists.js+0−33

@@ -1,33 +0,0 @@
1
2	var fs = require('fs');
3
4	function exists (path, isFile, isDirectory) {
5	try {
6	var matches = false;
7	var stat = fs.statSync(path);
8
9	matches = matches \|\| isFile && stat.isFile();
10	matches = matches \|\| isDirectory && stat.isDirectory();
11
12	return matches;
13	}
14	catch (e) {
15	if (e.code === 'ENOENT') {
16	return false;
17	}
18
19	throw e;
20	}
21	}
22
23	module.exports = function (path, type) {
24	if (!type) {
25	return exists(path, true, true);
26	}
27
28	return exists(path, type & 1, type & 2);
29	};
30
31	module.exports.FILE = 1;
32
33	module.exports.FOLDER = 2;

node_modules/simple-git/typings/response.d.ts+0−220

@@ -1,220 +0,0 @@
1	export interface BranchDeletionSummary {
2	branch: string;
3	hash: any;
4	success: boolean;
5	}
6
7	export interface BranchSummary {
8	detached: boolean;
9	current: string;
10	all: string[];
11	branches: {
12	[key: string]: {
13	current: boolean;
14	name: string;
15	commit: string;
16	label: string;
17	};
18	};
19	}
20
21	export interface CommitSummary {
22	author: null \| {
23	email: string;
24	name: string;
25	};
26	branch: string;
27	commit: string;
28	summary: {
29	changes: number;
30	insertions: number;
31	deletions: number;
32	};
33	}
34
35	export interface DiffResultTextFile {
36	file: string;
37	changes: number;
38	insertions: number;
39	deletions: number;
40	binary: boolean;
41	}
42
43	export interface DiffResultBinaryFile {
44	file: string;
45	before: number;
46	after: number;
47	binary: boolean;
48	}
49
50	export interface DiffResult {
51	/** The total number of files changed as reported in the summary line */
52	changed: number;
53
54	/** When present in the diff, lists the details of each file changed */
55	files: Array<DiffResultTextFile \| DiffResultBinaryFile>;
56
57	/** The number of files changed with insertions */
58	insertions: number;
59
60	/** The number of files changed with deletions */
61	deletions: number;
62	}
63
64	export interface FetchResult {
65	raw: string;
66	remote: string \| null;
67	branches: {
68	name: string;
69	tracking: string;
70	}[];
71	tags: {
72	name: string;
73	tracking: string;
74	}[];
75	}
76
77	export interface MoveSummary {
78	moves: any[];
79	}
80
81	export interface PullResult {
82	/** Array of all files that are referenced in the pull */
83	files: string[];
84
85	/** Map of file names to the number of insertions in that file */
86	insertions: { [key: string]: number };
87
88	/** Map of file names to the number of deletions in that file */
89	deletions: any;
90
91	summary: {
92	changes: number;
93	insertions: number;
94	deletions: number;
95	};
96
97	/** Array of file names that have been created */
98	created: string[];
99
100	/** Array of file names that have been deleted */
101	deleted: string[];
102	}
103
104	export interface RemoteWithoutRefs {
105	name: string;
106	}
107
108	export interface RemoteWithRefs extends RemoteWithoutRefs {
109	refs: {
110	fetch: string;
111	push: string;
112	};
113	}
114
115	export interface StatusResultRenamed {
116	from: string;
117	to: string;
118	}
119
120	export interface FileStatusSumary {
121	/* Path of the file */
122	path: string;
123	/* First digit of the status code of the file, e.g. 'M' = modified.
124	Represents the status of the index if no merge conflicts, otherwise represents
125	status of one side of the merge. */
126	index: string;
127	/* Second digit of the status code of the file. Represents status of the working directory
128	if no merge conflicts, otherwise represents status of other side of a merge. */
129	working_dir: string;
130	}
131
132	export interface StatusResult {
133	not_added: string[];
134	conflicted: string[];
135	created: string[];
136	deleted: string[];
137	modified: string[];
138	renamed: StatusResultRenamed[];
139	staged: string[];
140	files: FileStatusSumary[];
141	ahead: number;
142	behind: number;
143	current: string;
144	tracking: string;
145
146	/**
147	* Gets whether this represents a clean working branch.
148	*/
149	isClean(): boolean;
150	}
151
152	export interface TagResult {
153	all: string[];
154	latest: string;
155	}
156
157	export interface DefaultLogFields {
158	hash: string;
159	date: string;
160	message: string;
161	refs: string;
162	body: string;
163	author_name: string;
164	author_email: string;
165	}
166
167	/**
168	* The ListLogLine represents a single entry in the `git.log`, the properties on the object
169	* are mixed in depending on the names used in the format (see `DefaultLogFields`), but some
170	* properties are dependent on the command used.
171	*/
172	export interface ListLogLine {
173	/**
174	* When using a `--stat=4096` or `--shortstat` options in the `git.log` or `git.stashList`,
175	* each entry in the `ListLogSummary` will also have a `diff` property representing as much
176	* detail as was given in the response.
177	*/
178	diff?: DiffResult;
179	}
180
181	export interface ListLogSummary<T = DefaultLogFields> {
182	all: ReadonlyArray<T & ListLogLine>;
183	total: number;
184	latest: T & ListLogLine;
185	}
186
187	/**
188	* Where the file was deleted, if there is a modify/delete conflict
189	*/
190	export interface MergeConflictDeletion {
191	deleteRef: string;
192	}
193
194	/**
195	* Represents a single file with conflicts in the MergeSummary
196	*/
197	export interface MergeConflict {
198
199	/**
200	* Type of conflict
201	*/
202	reason: string;
203
204	/**
205	* Path to file
206	*/
207	file: string;
208
209	/**
210	* Additional detail for the specific type of conflict
211	*/
212	meta?: MergeConflictDeletion;
213	}
214
215	export interface MergeSummary extends PullResult {
216	conflicts: MergeConflict[];
217	merges: string[];
218	result: "success" \| string;
219	failed: boolean;
220	}