upstream/mercurial-mirror Commit - r44630:5d85e9dd

phabricator: fix a crash when submitting binaries (issue6260)...

Matt Harbison -

r44630:5d85e9dd stable

parent child

tests/phabricator/phabsend-binary.json

0 created 644 +1909 0

This diff has been collapsed as it changes many lines, (1909 lines changed) Show them Hide them
	@@ -0,0 +1,1909 b''
		1	{
		2	"version": 1,
		3	"interactions": [
		4	{
		5	"response": {
		6	"status": {
		7	"message": "OK",
		8	"code": 200
		9	},
		10	"headers": {
		11	"strict-transport-security": [
		12	"max-age=0; includeSubdomains; preload"
		13	],
		14	"server": [
		15	"Apache/2.4.10 (Debian)"
		16	],
		17	"referrer-policy": [
		18	"no-referrer"
		19	],
		20	"x-frame-options": [
		21	"Deny"
		22	],
		23	"expires": [
		24	"Sat, 01 Jan 2000 00:00:00 GMT"
		25	],
		26	"x-content-type-options": [
		27	"nosniff"
		28	],
		29	"cache-control": [
		30	"no-store"
		31	],
		32	"content-type": [
		33	"application/json"
		34	],
		35	"x-xss-protection": [
		36	"1; mode=block"
		37	],
		38	"transfer-encoding": [
		39	"chunked"
		40	],
		41	"date": [
		42	"Sat, 25 Jan 2020 06:01:03 GMT"
		43	]
		44	},
		45	"body": {
		46	"string": "{\"result\":{\"data\":[{\"id\":2,\"type\":\"REPO\",\"phid\":\"PHID-REPO-bvunnehri4u2isyr7bc3\",\"fields\":{\"name\":\"Mercurial\",\"vcs\":\"hg\",\"callsign\":\"HG\",\"shortName\":null,\"status\":\"active\",\"isImporting\":false,\"almanacServicePHID\":null,\"refRules\":{\"fetchRules\":[],\"trackRules\":[],\"permanentRefRules\":[]},\"spacePHID\":null,\"dateCreated\":1498761653,\"dateModified\":1500403184,\"policy\":{\"view\":\"public\",\"edit\":\"admin\",\"diffusion.push\":\"users\"}},\"attachments\":{}}],\"maps\":{},\"query\":{\"queryKey\":null},\"cursor\":{\"limit\":100,\"after\":null,\"before\":null,\"order\":null}},\"error_code\":null,\"error_info\":null}"
		47	}
		48	},
		49	"request": {
		50	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22constraints%22%3A+%7B%22callsigns%22%3A+%5B%22HG%22%5D%7D%7D",
		51	"method": "POST",
		52	"headers": {
		53	"content-type": [
		54	"application/x-www-form-urlencoded"
		55	],
		56	"user-agent": [
		57	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		58	],
		59	"content-length": [
		60	"183"
		61	],
		62	"host": [
		63	"phab.mercurial-scm.org"
		64	],
		65	"accept": [
		66	"application/mercurial-0.1"
		67	]
		68	},
		69	"uri": "https://phab.mercurial-scm.org//api/diffusion.repository.search"
		70	}
		71	},
		72	{
		73	"response": {
		74	"status": {
		75	"message": "OK",
		76	"code": 200
		77	},
		78	"headers": {
		79	"strict-transport-security": [
		80	"max-age=0; includeSubdomains; preload"
		81	],
		82	"server": [
		83	"Apache/2.4.10 (Debian)"
		84	],
		85	"referrer-policy": [
		86	"no-referrer"
		87	],
		88	"x-frame-options": [
		89	"Deny"
		90	],
		91	"expires": [
		92	"Sat, 01 Jan 2000 00:00:00 GMT"
		93	],
		94	"x-content-type-options": [
		95	"nosniff"
		96	],
		97	"cache-control": [
		98	"no-store"
		99	],
		100	"content-type": [
		101	"application/json"
		102	],
		103	"x-xss-protection": [
		104	"1; mode=block"
		105	],
		106	"transfer-encoding": [
		107	"chunked"
		108	],
		109	"date": [
		110	"Sat, 25 Jan 2020 06:01:04 GMT"
		111	]
		112	},
		113	"body": {
		114	"string": "{\"result\":{\"upload\":true,\"filePHID\":null},\"error_code\":null,\"error_info\":null}"
		115	}
		116	},
		117	"request": {
		118	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22contentHash%22%3A+%22022a6979e6dab7aa5ae4c3e5e45f7e977112a7e63593820dbec1ec738a24f93c%22%2C+%22contentLength%22%3A+2%2C+%22name%22%3A+%22bin%22%7D",
		119	"method": "POST",
		120	"headers": {
		121	"content-type": [
		122	"application/x-www-form-urlencoded"
		123	],
		124	"user-agent": [
		125	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		126	],
		127	"content-length": [
		128	"269"
		129	],
		130	"host": [
		131	"phab.mercurial-scm.org"
		132	],
		133	"accept": [
		134	"application/mercurial-0.1"
		135	]
		136	},
		137	"uri": "https://phab.mercurial-scm.org//api/file.allocate"
		138	}
		139	},
		140	{
		141	"response": {
		142	"status": {
		143	"message": "OK",
		144	"code": 200
		145	},
		146	"headers": {
		147	"strict-transport-security": [
		148	"max-age=0; includeSubdomains; preload"
		149	],
		150	"server": [
		151	"Apache/2.4.10 (Debian)"
		152	],
		153	"referrer-policy": [
		154	"no-referrer"
		155	],
		156	"x-frame-options": [
		157	"Deny"
		158	],
		159	"expires": [
		160	"Sat, 01 Jan 2000 00:00:00 GMT"
		161	],
		162	"x-content-type-options": [
		163	"nosniff"
		164	],
		165	"cache-control": [
		166	"no-store"
		167	],
		168	"content-type": [
		169	"application/json"
		170	],
		171	"x-xss-protection": [
		172	"1; mode=block"
		173	],
		174	"transfer-encoding": [
		175	"chunked"
		176	],
		177	"date": [
		178	"Sat, 25 Jan 2020 06:01:04 GMT"
		179	]
		180	},
		181	"body": {
		182	"string": "{\"result\":\"PHID-FILE-6icohlowpfhuvuut4kt4\",\"error_code\":null,\"error_info\":null}"
		183	}
		184	},
		185	"request": {
		186	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data_base64%22%3A+%22AGE%3D%22%2C+%22name%22%3A+%22bin%22%7D",
		187	"method": "POST",
		188	"headers": {
		189	"content-type": [
		190	"application/x-www-form-urlencoded"
		191	],
		192	"user-agent": [
		193	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		194	],
		195	"content-length": [
		196	"183"
		197	],
		198	"host": [
		199	"phab.mercurial-scm.org"
		200	],
		201	"accept": [
		202	"application/mercurial-0.1"
		203	]
		204	},
		205	"uri": "https://phab.mercurial-scm.org//api/file.upload"
		206	}
		207	},
		208	{
		209	"response": {
		210	"status": {
		211	"message": "OK",
		212	"code": 200
		213	},
		214	"headers": {
		215	"strict-transport-security": [
		216	"max-age=0; includeSubdomains; preload"
		217	],
		218	"server": [
		219	"Apache/2.4.10 (Debian)"
		220	],
		221	"referrer-policy": [
		222	"no-referrer"
		223	],
		224	"x-frame-options": [
		225	"Deny"
		226	],
		227	"expires": [
		228	"Sat, 01 Jan 2000 00:00:00 GMT"
		229	],
		230	"x-content-type-options": [
		231	"nosniff"
		232	],
		233	"cache-control": [
		234	"no-store"
		235	],
		236	"content-type": [
		237	"application/json"
		238	],
		239	"x-xss-protection": [
		240	"1; mode=block"
		241	],
		242	"transfer-encoding": [
		243	"chunked"
		244	],
		245	"date": [
		246	"Sat, 25 Jan 2020 06:01:05 GMT"
		247	]
		248	},
		249	"body": {
		250	"string": "{\"result\":{\"diffid\":19599,\"phid\":\"PHID-DIFF-uvk7qaq6iglk4wgk2lxb\",\"uri\":\"https:\\/\\/phab.mercurial-scm.org\\/differential\\/diff\\/19599\\/\"},\"error_code\":null,\"error_info\":null}"
		251	}
		252	},
		253	"request": {
		254	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22bookmark%22%3A+null%2C+%22branch%22%3A+%22default%22%2C+%22changes%22%3A+%7B%22bin%22%3A+%7B%22addLines%22%3A+0%2C+%22awayPaths%22%3A+%5B%5D%2C+%22commitHash%22%3A+null%2C+%22currentPath%22%3A+%22bin%22%2C+%22delLines%22%3A+0%2C+%22fileType%22%3A+3%2C+%22hunks%22%3A+%5B%5D%2C+%22metadata%22%3A+%7B%22new%3Abinary-phid%22%3A+%22PHID-FILE-6icohlowpfhuvuut4kt4%22%2C+%22new%3Afile%3Asize%22%3A+2%7D%2C+%22newProperties%22%3A+%7B%22unix%3Afilemode%22%3A+%22100644%22%7D%2C+%22oldPath%22%3A+null%2C+%22oldProperties%22%3A+%7B%7D%2C+%22type%22%3A+1%7D%7D%2C+%22creationMethod%22%3A+%22phabsend%22%2C+%22lintStatus%22%3A+%22none%22%2C+%22repositoryPHID%22%3A+%22PHID-REPO-bvunnehri4u2isyr7bc3%22%2C+%22sourceControlBaseRevision%22%3A+%221849d7828727a28e14c589323e4f8c9a1c8d2816%22%2C+%22sourceControlPath%22%3A+%22%2F%22%2C+%22sourceControlSystem%22%3A+%22hg%22%2C+%22sourceMachine%22%3A+%22%22%2C+%22sourcePath%22%3A+%22%2F%22%2C+%22unitStatus%22%3A+%22none%22%7D",
		255	"method": "POST",
		256	"headers": {
		257	"content-type": [
		258	"application/x-www-form-urlencoded"
		259	],
		260	"user-agent": [
		261	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		262	],
		263	"content-length": [
		264	"1081"
		265	],
		266	"host": [
		267	"phab.mercurial-scm.org"
		268	],
		269	"accept": [
		270	"application/mercurial-0.1"
		271	]
		272	},
		273	"uri": "https://phab.mercurial-scm.org//api/differential.creatediff"
		274	}
		275	},
		276	{
		277	"response": {
		278	"status": {
		279	"message": "OK",
		280	"code": 200
		281	},
		282	"headers": {
		283	"strict-transport-security": [
		284	"max-age=0; includeSubdomains; preload"
		285	],
		286	"server": [
		287	"Apache/2.4.10 (Debian)"
		288	],
		289	"referrer-policy": [
		290	"no-referrer"
		291	],
		292	"x-frame-options": [
		293	"Deny"
		294	],
		295	"expires": [
		296	"Sat, 01 Jan 2000 00:00:00 GMT"
		297	],
		298	"x-content-type-options": [
		299	"nosniff"
		300	],
		301	"cache-control": [
		302	"no-store"
		303	],
		304	"content-type": [
		305	"application/json"
		306	],
		307	"x-xss-protection": [
		308	"1; mode=block"
		309	],
		310	"transfer-encoding": [
		311	"chunked"
		312	],
		313	"date": [
		314	"Sat, 25 Jan 2020 06:01:06 GMT"
		315	]
		316	},
		317	"body": {
		318	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		319	}
		320	},
		321	"request": {
		322	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22date%5C%22%3A+%5C%220+0%5C%22%2C+%5C%22node%5C%22%3A+%5C%22aa24a81f55de50addfce4a824eeb919d59b19683%5C%22%2C+%5C%22parent%5C%22%3A+%5C%221849d7828727a28e14c589323e4f8c9a1c8d2816%5C%22%2C+%5C%22user%5C%22%3A+%5C%22test%5C%22%7D%22%2C+%22diff_id%22%3A+19599%2C+%22name%22%3A+%22hg%3Ameta%22%7D",
		323	"method": "POST",
		324	"headers": {
		325	"content-type": [
		326	"application/x-www-form-urlencoded"
		327	],
		328	"user-agent": [
		329	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		330	],
		331	"content-length": [
		332	"482"
		333	],
		334	"host": [
		335	"phab.mercurial-scm.org"
		336	],
		337	"accept": [
		338	"application/mercurial-0.1"
		339	]
		340	},
		341	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		342	}
		343	},
		344	{
		345	"response": {
		346	"status": {
		347	"message": "OK",
		348	"code": 200
		349	},
		350	"headers": {
		351	"strict-transport-security": [
		352	"max-age=0; includeSubdomains; preload"
		353	],
		354	"server": [
		355	"Apache/2.4.10 (Debian)"
		356	],
		357	"referrer-policy": [
		358	"no-referrer"
		359	],
		360	"x-frame-options": [
		361	"Deny"
		362	],
		363	"expires": [
		364	"Sat, 01 Jan 2000 00:00:00 GMT"
		365	],
		366	"x-content-type-options": [
		367	"nosniff"
		368	],
		369	"cache-control": [
		370	"no-store"
		371	],
		372	"content-type": [
		373	"application/json"
		374	],
		375	"x-xss-protection": [
		376	"1; mode=block"
		377	],
		378	"transfer-encoding": [
		379	"chunked"
		380	],
		381	"date": [
		382	"Sat, 25 Jan 2020 06:01:06 GMT"
		383	]
		384	},
		385	"body": {
		386	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		387	}
		388	},
		389	"request": {
		390	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22aa24a81f55de50addfce4a824eeb919d59b19683%5C%22%3A+%7B%5C%22author%5C%22%3A+%5C%22test%5C%22%2C+%5C%22authorEmail%5C%22%3A+%5C%22test%5C%22%2C+%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22commit%5C%22%3A+%5C%22aa24a81f55de50addfce4a824eeb919d59b19683%5C%22%2C+%5C%22parents%5C%22%3A+%5B%5C%221849d7828727a28e14c589323e4f8c9a1c8d2816%5C%22%5D%2C+%5C%22time%5C%22%3A+0%7D%7D%22%2C+%22diff_id%22%3A+19599%2C+%22name%22%3A+%22local%3Acommits%22%7D",
		391	"method": "POST",
		392	"headers": {
		393	"content-type": [
		394	"application/x-www-form-urlencoded"
		395	],
		396	"user-agent": [
		397	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		398	],
		399	"content-length": [
		400	"594"
		401	],
		402	"host": [
		403	"phab.mercurial-scm.org"
		404	],
		405	"accept": [
		406	"application/mercurial-0.1"
		407	]
		408	},
		409	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		410	}
		411	},
		412	{
		413	"response": {
		414	"status": {
		415	"message": "OK",
		416	"code": 200
		417	},
		418	"headers": {
		419	"strict-transport-security": [
		420	"max-age=0; includeSubdomains; preload"
		421	],
		422	"server": [
		423	"Apache/2.4.10 (Debian)"
		424	],
		425	"referrer-policy": [
		426	"no-referrer"
		427	],
		428	"x-frame-options": [
		429	"Deny"
		430	],
		431	"expires": [
		432	"Sat, 01 Jan 2000 00:00:00 GMT"
		433	],
		434	"x-content-type-options": [
		435	"nosniff"
		436	],
		437	"cache-control": [
		438	"no-store"
		439	],
		440	"content-type": [
		441	"application/json"
		442	],
		443	"x-xss-protection": [
		444	"1; mode=block"
		445	],
		446	"transfer-encoding": [
		447	"chunked"
		448	],
		449	"date": [
		450	"Sat, 25 Jan 2020 06:01:07 GMT"
		451	]
		452	},
		453	"body": {
		454	"string": "{\"result\":{\"errors\":[],\"fields\":{\"title\":\"add binary\"},\"revisionIDFieldInfo\":{\"value\":null,\"validDomain\":\"https:\\/\\/phab.mercurial-scm.org\"},\"transactions\":[{\"type\":\"title\",\"value\":\"add binary\"}]},\"error_code\":null,\"error_info\":null}"
		455	}
		456	},
		457	"request": {
		458	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22corpus%22%3A+%22add+binary%22%7D",
		459	"method": "POST",
		460	"headers": {
		461	"content-type": [
		462	"application/x-www-form-urlencoded"
		463	],
		464	"user-agent": [
		465	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		466	],
		467	"content-length": [
		468	"155"
		469	],
		470	"host": [
		471	"phab.mercurial-scm.org"
		472	],
		473	"accept": [
		474	"application/mercurial-0.1"
		475	]
		476	},
		477	"uri": "https://phab.mercurial-scm.org//api/differential.parsecommitmessage"
		478	}
		479	},
		480	{
		481	"response": {
		482	"status": {
		483	"message": "OK",
		484	"code": 200
		485	},
		486	"headers": {
		487	"strict-transport-security": [
		488	"max-age=0; includeSubdomains; preload"
		489	],
		490	"server": [
		491	"Apache/2.4.10 (Debian)"
		492	],
		493	"referrer-policy": [
		494	"no-referrer"
		495	],
		496	"x-frame-options": [
		497	"Deny"
		498	],
		499	"expires": [
		500	"Sat, 01 Jan 2000 00:00:00 GMT"
		501	],
		502	"x-content-type-options": [
		503	"nosniff"
		504	],
		505	"cache-control": [
		506	"no-store"
		507	],
		508	"content-type": [
		509	"application/json"
		510	],
		511	"x-xss-protection": [
		512	"1; mode=block"
		513	],
		514	"transfer-encoding": [
		515	"chunked"
		516	],
		517	"date": [
		518	"Sat, 25 Jan 2020 06:01:08 GMT"
		519	]
		520	},
		521	"body": {
		522	"string": "{\"result\":{\"object\":{\"id\":8007,\"phid\":\"PHID-DREV-477vjqq7vbddmjluy2cd\"},\"transactions\":[{\"phid\":\"PHID-XACT-DREV-3mzn77j7wvia63r\"},{\"phid\":\"PHID-XACT-DREV-qs7abx4c65qud72\"},{\"phid\":\"PHID-XACT-DREV-yzrxnvdwpapxruz\"},{\"phid\":\"PHID-XACT-DREV-byrci62wwrwl262\"},{\"phid\":\"PHID-XACT-DREV-3ialrkyr7elyr72\"}]},\"error_code\":null,\"error_info\":null}"
		523	}
		524	},
		525	"request": {
		526	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22transactions%22%3A+%5B%7B%22type%22%3A+%22update%22%2C+%22value%22%3A+%22PHID-DIFF-uvk7qaq6iglk4wgk2lxb%22%7D%2C+%7B%22type%22%3A+%22title%22%2C+%22value%22%3A+%22add+binary%22%7D%5D%7D",
		527	"method": "POST",
		528	"headers": {
		529	"content-type": [
		530	"application/x-www-form-urlencoded"
		531	],
		532	"user-agent": [
		533	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		534	],
		535	"content-length": [
		536	"308"
		537	],
		538	"host": [
		539	"phab.mercurial-scm.org"
		540	],
		541	"accept": [
		542	"application/mercurial-0.1"
		543	]
		544	},
		545	"uri": "https://phab.mercurial-scm.org//api/differential.revision.edit"
		546	}
		547	},
		548	{
		549	"response": {
		550	"status": {
		551	"message": "OK",
		552	"code": 200
		553	},
		554	"headers": {
		555	"strict-transport-security": [
		556	"max-age=0; includeSubdomains; preload"
		557	],
		558	"server": [
		559	"Apache/2.4.10 (Debian)"
		560	],
		561	"referrer-policy": [
		562	"no-referrer"
		563	],
		564	"x-frame-options": [
		565	"Deny"
		566	],
		567	"expires": [
		568	"Sat, 01 Jan 2000 00:00:00 GMT"
		569	],
		570	"x-content-type-options": [
		571	"nosniff"
		572	],
		573	"cache-control": [
		574	"no-store"
		575	],
		576	"content-type": [
		577	"application/json"
		578	],
		579	"x-xss-protection": [
		580	"1; mode=block"
		581	],
		582	"transfer-encoding": [
		583	"chunked"
		584	],
		585	"date": [
		586	"Sat, 25 Jan 2020 06:01:08 GMT"
		587	]
		588	},
		589	"body": {
		590	"string": "{\"result\":{\"upload\":true,\"filePHID\":null},\"error_code\":null,\"error_info\":null}"
		591	}
		592	},
		593	"request": {
		594	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22contentHash%22%3A+%2257eb35615d47f34ec714cacdf5fd74608a5e8e102724e80b24b287c0c27b6a31%22%2C+%22contentLength%22%3A+2%2C+%22name%22%3A+%22bin%22%7D",
		595	"method": "POST",
		596	"headers": {
		597	"content-type": [
		598	"application/x-www-form-urlencoded"
		599	],
		600	"user-agent": [
		601	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		602	],
		603	"content-length": [
		604	"269"
		605	],
		606	"host": [
		607	"phab.mercurial-scm.org"
		608	],
		609	"accept": [
		610	"application/mercurial-0.1"
		611	]
		612	},
		613	"uri": "https://phab.mercurial-scm.org//api/file.allocate"
		614	}
		615	},
		616	{
		617	"response": {
		618	"status": {
		619	"message": "OK",
		620	"code": 200
		621	},
		622	"headers": {
		623	"strict-transport-security": [
		624	"max-age=0; includeSubdomains; preload"
		625	],
		626	"server": [
		627	"Apache/2.4.10 (Debian)"
		628	],
		629	"referrer-policy": [
		630	"no-referrer"
		631	],
		632	"x-frame-options": [
		633	"Deny"
		634	],
		635	"expires": [
		636	"Sat, 01 Jan 2000 00:00:00 GMT"
		637	],
		638	"x-content-type-options": [
		639	"nosniff"
		640	],
		641	"cache-control": [
		642	"no-store"
		643	],
		644	"content-type": [
		645	"application/json"
		646	],
		647	"x-xss-protection": [
		648	"1; mode=block"
		649	],
		650	"transfer-encoding": [
		651	"chunked"
		652	],
		653	"date": [
		654	"Sat, 25 Jan 2020 06:01:09 GMT"
		655	]
		656	},
		657	"body": {
		658	"string": "{\"result\":\"PHID-FILE-smitcgkxyyu7u3qodnmj\",\"error_code\":null,\"error_info\":null}"
		659	}
		660	},
		661	"request": {
		662	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data_base64%22%3A+%22AGI%3D%22%2C+%22name%22%3A+%22bin%22%7D",
		663	"method": "POST",
		664	"headers": {
		665	"content-type": [
		666	"application/x-www-form-urlencoded"
		667	],
		668	"user-agent": [
		669	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		670	],
		671	"content-length": [
		672	"183"
		673	],
		674	"host": [
		675	"phab.mercurial-scm.org"
		676	],
		677	"accept": [
		678	"application/mercurial-0.1"
		679	]
		680	},
		681	"uri": "https://phab.mercurial-scm.org//api/file.upload"
		682	}
		683	},
		684	{
		685	"response": {
		686	"status": {
		687	"message": "OK",
		688	"code": 200
		689	},
		690	"headers": {
		691	"strict-transport-security": [
		692	"max-age=0; includeSubdomains; preload"
		693	],
		694	"server": [
		695	"Apache/2.4.10 (Debian)"
		696	],
		697	"referrer-policy": [
		698	"no-referrer"
		699	],
		700	"x-frame-options": [
		701	"Deny"
		702	],
		703	"expires": [
		704	"Sat, 01 Jan 2000 00:00:00 GMT"
		705	],
		706	"x-content-type-options": [
		707	"nosniff"
		708	],
		709	"cache-control": [
		710	"no-store"
		711	],
		712	"content-type": [
		713	"application/json"
		714	],
		715	"x-xss-protection": [
		716	"1; mode=block"
		717	],
		718	"transfer-encoding": [
		719	"chunked"
		720	],
		721	"date": [
		722	"Sat, 25 Jan 2020 06:01:10 GMT"
		723	]
		724	},
		725	"body": {
		726	"string": "{\"result\":{\"upload\":false,\"filePHID\":\"PHID-FILE-ulotc37zwk3yic5hh72n\"},\"error_code\":null,\"error_info\":null}"
		727	}
		728	},
		729	"request": {
		730	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22contentHash%22%3A+%22022a6979e6dab7aa5ae4c3e5e45f7e977112a7e63593820dbec1ec738a24f93c%22%2C+%22contentLength%22%3A+2%2C+%22name%22%3A+%22bin%22%7D",
		731	"method": "POST",
		732	"headers": {
		733	"content-type": [
		734	"application/x-www-form-urlencoded"
		735	],
		736	"user-agent": [
		737	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		738	],
		739	"content-length": [
		740	"269"
		741	],
		742	"host": [
		743	"phab.mercurial-scm.org"
		744	],
		745	"accept": [
		746	"application/mercurial-0.1"
		747	]
		748	},
		749	"uri": "https://phab.mercurial-scm.org//api/file.allocate"
		750	}
		751	},
		752	{
		753	"response": {
		754	"status": {
		755	"message": "OK",
		756	"code": 200
		757	},
		758	"headers": {
		759	"strict-transport-security": [
		760	"max-age=0; includeSubdomains; preload"
		761	],
		762	"server": [
		763	"Apache/2.4.10 (Debian)"
		764	],
		765	"referrer-policy": [
		766	"no-referrer"
		767	],
		768	"x-frame-options": [
		769	"Deny"
		770	],
		771	"expires": [
		772	"Sat, 01 Jan 2000 00:00:00 GMT"
		773	],
		774	"x-content-type-options": [
		775	"nosniff"
		776	],
		777	"cache-control": [
		778	"no-store"
		779	],
		780	"content-type": [
		781	"application/json"
		782	],
		783	"x-xss-protection": [
		784	"1; mode=block"
		785	],
		786	"transfer-encoding": [
		787	"chunked"
		788	],
		789	"date": [
		790	"Sat, 25 Jan 2020 06:01:10 GMT"
		791	]
		792	},
		793	"body": {
		794	"string": "{\"result\":{\"diffid\":19600,\"phid\":\"PHID-DIFF-wdmlzkf4huoiqpl4vbsr\",\"uri\":\"https:\\/\\/phab.mercurial-scm.org\\/differential\\/diff\\/19600\\/\"},\"error_code\":null,\"error_info\":null}"
		795	}
		796	},
		797	"request": {
		798	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22bookmark%22%3A+null%2C+%22branch%22%3A+%22default%22%2C+%22changes%22%3A+%7B%22bin%22%3A+%7B%22addLines%22%3A+0%2C+%22awayPaths%22%3A+%5B%5D%2C+%22commitHash%22%3A+null%2C+%22currentPath%22%3A+%22bin%22%2C+%22delLines%22%3A+0%2C+%22fileType%22%3A+3%2C+%22hunks%22%3A+%5B%5D%2C+%22metadata%22%3A+%7B%22new%3Abinary-phid%22%3A+%22PHID-FILE-smitcgkxyyu7u3qodnmj%22%2C+%22new%3Afile%3Asize%22%3A+2%2C+%22old%3Abinary-phid%22%3A+%22PHID-FILE-ulotc37zwk3yic5hh72n%22%2C+%22old%3Afile%3Asize%22%3A+2%7D%2C+%22newProperties%22%3A+%7B%7D%2C+%22oldPath%22%3A+%22bin%22%2C+%22oldProperties%22%3A+%7B%7D%2C+%22type%22%3A+2%7D%7D%2C+%22creationMethod%22%3A+%22phabsend%22%2C+%22lintStatus%22%3A+%22none%22%2C+%22repositoryPHID%22%3A+%22PHID-REPO-bvunnehri4u2isyr7bc3%22%2C+%22sourceControlBaseRevision%22%3A+%22aa24a81f55de50addfce4a824eeb919d59b19683%22%2C+%22sourceControlPath%22%3A+%22%2F%22%2C+%22sourceControlSystem%22%3A+%22hg%22%2C+%22sourceMachine%22%3A+%22%22%2C+%22sourcePath%22%3A+%22%2F%22%2C+%22unitStatus%22%3A+%22none%22%7D",
		799	"method": "POST",
		800	"headers": {
		801	"content-type": [
		802	"application/x-www-form-urlencoded"
		803	],
		804	"user-agent": [
		805	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		806	],
		807	"content-length": [
		808	"1148"
		809	],
		810	"host": [
		811	"phab.mercurial-scm.org"
		812	],
		813	"accept": [
		814	"application/mercurial-0.1"
		815	]
		816	},
		817	"uri": "https://phab.mercurial-scm.org//api/differential.creatediff"
		818	}
		819	},
		820	{
		821	"response": {
		822	"status": {
		823	"message": "OK",
		824	"code": 200
		825	},
		826	"headers": {
		827	"strict-transport-security": [
		828	"max-age=0; includeSubdomains; preload"
		829	],
		830	"server": [
		831	"Apache/2.4.10 (Debian)"
		832	],
		833	"referrer-policy": [
		834	"no-referrer"
		835	],
		836	"x-frame-options": [
		837	"Deny"
		838	],
		839	"expires": [
		840	"Sat, 01 Jan 2000 00:00:00 GMT"
		841	],
		842	"x-content-type-options": [
		843	"nosniff"
		844	],
		845	"cache-control": [
		846	"no-store"
		847	],
		848	"content-type": [
		849	"application/json"
		850	],
		851	"x-xss-protection": [
		852	"1; mode=block"
		853	],
		854	"transfer-encoding": [
		855	"chunked"
		856	],
		857	"date": [
		858	"Sat, 25 Jan 2020 06:01:11 GMT"
		859	]
		860	},
		861	"body": {
		862	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		863	}
		864	},
		865	"request": {
		866	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22date%5C%22%3A+%5C%220+0%5C%22%2C+%5C%22node%5C%22%3A+%5C%22d8d62a881b546814f012cef7c1bd0c438cc153e2%5C%22%2C+%5C%22parent%5C%22%3A+%5C%22aa24a81f55de50addfce4a824eeb919d59b19683%5C%22%2C+%5C%22user%5C%22%3A+%5C%22test%5C%22%7D%22%2C+%22diff_id%22%3A+19600%2C+%22name%22%3A+%22hg%3Ameta%22%7D",
		867	"method": "POST",
		868	"headers": {
		869	"content-type": [
		870	"application/x-www-form-urlencoded"
		871	],
		872	"user-agent": [
		873	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		874	],
		875	"content-length": [
		876	"482"
		877	],
		878	"host": [
		879	"phab.mercurial-scm.org"
		880	],
		881	"accept": [
		882	"application/mercurial-0.1"
		883	]
		884	},
		885	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		886	}
		887	},
		888	{
		889	"response": {
		890	"status": {
		891	"message": "OK",
		892	"code": 200
		893	},
		894	"headers": {
		895	"strict-transport-security": [
		896	"max-age=0; includeSubdomains; preload"
		897	],
		898	"server": [
		899	"Apache/2.4.10 (Debian)"
		900	],
		901	"referrer-policy": [
		902	"no-referrer"
		903	],
		904	"x-frame-options": [
		905	"Deny"
		906	],
		907	"expires": [
		908	"Sat, 01 Jan 2000 00:00:00 GMT"
		909	],
		910	"x-content-type-options": [
		911	"nosniff"
		912	],
		913	"cache-control": [
		914	"no-store"
		915	],
		916	"content-type": [
		917	"application/json"
		918	],
		919	"x-xss-protection": [
		920	"1; mode=block"
		921	],
		922	"transfer-encoding": [
		923	"chunked"
		924	],
		925	"date": [
		926	"Sat, 25 Jan 2020 06:01:12 GMT"
		927	]
		928	},
		929	"body": {
		930	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		931	}
		932	},
		933	"request": {
		934	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22d8d62a881b546814f012cef7c1bd0c438cc153e2%5C%22%3A+%7B%5C%22author%5C%22%3A+%5C%22test%5C%22%2C+%5C%22authorEmail%5C%22%3A+%5C%22test%5C%22%2C+%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22commit%5C%22%3A+%5C%22d8d62a881b546814f012cef7c1bd0c438cc153e2%5C%22%2C+%5C%22parents%5C%22%3A+%5B%5C%22aa24a81f55de50addfce4a824eeb919d59b19683%5C%22%5D%2C+%5C%22time%5C%22%3A+0%7D%7D%22%2C+%22diff_id%22%3A+19600%2C+%22name%22%3A+%22local%3Acommits%22%7D",
		935	"method": "POST",
		936	"headers": {
		937	"content-type": [
		938	"application/x-www-form-urlencoded"
		939	],
		940	"user-agent": [
		941	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		942	],
		943	"content-length": [
		944	"594"
		945	],
		946	"host": [
		947	"phab.mercurial-scm.org"
		948	],
		949	"accept": [
		950	"application/mercurial-0.1"
		951	]
		952	},
		953	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		954	}
		955	},
		956	{
		957	"response": {
		958	"status": {
		959	"message": "OK",
		960	"code": 200
		961	},
		962	"headers": {
		963	"strict-transport-security": [
		964	"max-age=0; includeSubdomains; preload"
		965	],
		966	"server": [
		967	"Apache/2.4.10 (Debian)"
		968	],
		969	"referrer-policy": [
		970	"no-referrer"
		971	],
		972	"x-frame-options": [
		973	"Deny"
		974	],
		975	"expires": [
		976	"Sat, 01 Jan 2000 00:00:00 GMT"
		977	],
		978	"x-content-type-options": [
		979	"nosniff"
		980	],
		981	"cache-control": [
		982	"no-store"
		983	],
		984	"content-type": [
		985	"application/json"
		986	],
		987	"x-xss-protection": [
		988	"1; mode=block"
		989	],
		990	"transfer-encoding": [
		991	"chunked"
		992	],
		993	"date": [
		994	"Sat, 25 Jan 2020 06:01:12 GMT"
		995	]
		996	},
		997	"body": {
		998	"string": "{\"result\":{\"errors\":[],\"fields\":{\"title\":\"modify binary\"},\"revisionIDFieldInfo\":{\"value\":null,\"validDomain\":\"https:\\/\\/phab.mercurial-scm.org\"},\"transactions\":[{\"type\":\"title\",\"value\":\"modify binary\"}]},\"error_code\":null,\"error_info\":null}"
		999	}
		1000	},
		1001	"request": {
		1002	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22corpus%22%3A+%22modify+binary%22%7D",
		1003	"method": "POST",
		1004	"headers": {
		1005	"content-type": [
		1006	"application/x-www-form-urlencoded"
		1007	],
		1008	"user-agent": [
		1009	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1010	],
		1011	"content-length": [
		1012	"158"
		1013	],
		1014	"host": [
		1015	"phab.mercurial-scm.org"
		1016	],
		1017	"accept": [
		1018	"application/mercurial-0.1"
		1019	]
		1020	},
		1021	"uri": "https://phab.mercurial-scm.org//api/differential.parsecommitmessage"
		1022	}
		1023	},
		1024	{
		1025	"response": {
		1026	"status": {
		1027	"message": "OK",
		1028	"code": 200
		1029	},
		1030	"headers": {
		1031	"strict-transport-security": [
		1032	"max-age=0; includeSubdomains; preload"
		1033	],
		1034	"server": [
		1035	"Apache/2.4.10 (Debian)"
		1036	],
		1037	"referrer-policy": [
		1038	"no-referrer"
		1039	],
		1040	"x-frame-options": [
		1041	"Deny"
		1042	],
		1043	"expires": [
		1044	"Sat, 01 Jan 2000 00:00:00 GMT"
		1045	],
		1046	"x-content-type-options": [
		1047	"nosniff"
		1048	],
		1049	"cache-control": [
		1050	"no-store"
		1051	],
		1052	"content-type": [
		1053	"application/json"
		1054	],
		1055	"x-xss-protection": [
		1056	"1; mode=block"
		1057	],
		1058	"transfer-encoding": [
		1059	"chunked"
		1060	],
		1061	"date": [
		1062	"Sat, 25 Jan 2020 06:01:13 GMT"
		1063	]
		1064	},
		1065	"body": {
		1066	"string": "{\"result\":{\"object\":{\"id\":8008,\"phid\":\"PHID-DREV-q5cr6ap6pwfczhlhjrmv\"},\"transactions\":[{\"phid\":\"PHID-XACT-DREV-54nmhipbtei7cmf\"},{\"phid\":\"PHID-XACT-DREV-zh5tb4ay2no4lr7\"},{\"phid\":\"PHID-XACT-DREV-mi6n5eteba4pb2h\"},{\"phid\":\"PHID-XACT-DREV-zmbupfrlsvzty6c\"},{\"phid\":\"PHID-XACT-DREV-h2mxx7gkkriw5b5\"},{\"phid\":\"PHID-XACT-DREV-6zpi3cnarzr5f6i\"}]},\"error_code\":null,\"error_info\":null}"
		1067	}
		1068	},
		1069	"request": {
		1070	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22transactions%22%3A+%5B%7B%22type%22%3A+%22update%22%2C+%22value%22%3A+%22PHID-DIFF-wdmlzkf4huoiqpl4vbsr%22%7D%2C+%7B%22type%22%3A+%22parents.set%22%2C+%22value%22%3A+%5B%22PHID-DREV-477vjqq7vbddmjluy2cd%22%5D%7D%2C+%7B%22type%22%3A+%22title%22%2C+%22value%22%3A+%22modify+binary%22%7D%5D%7D",
		1071	"method": "POST",
		1072	"headers": {
		1073	"content-type": [
		1074	"application/x-www-form-urlencoded"
		1075	],
		1076	"user-agent": [
		1077	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1078	],
		1079	"content-length": [
		1080	"413"
		1081	],
		1082	"host": [
		1083	"phab.mercurial-scm.org"
		1084	],
		1085	"accept": [
		1086	"application/mercurial-0.1"
		1087	]
		1088	},
		1089	"uri": "https://phab.mercurial-scm.org//api/differential.revision.edit"
		1090	}
		1091	},
		1092	{
		1093	"response": {
		1094	"status": {
		1095	"message": "OK",
		1096	"code": 200
		1097	},
		1098	"headers": {
		1099	"strict-transport-security": [
		1100	"max-age=0; includeSubdomains; preload"
		1101	],
		1102	"server": [
		1103	"Apache/2.4.10 (Debian)"
		1104	],
		1105	"referrer-policy": [
		1106	"no-referrer"
		1107	],
		1108	"x-frame-options": [
		1109	"Deny"
		1110	],
		1111	"expires": [
		1112	"Sat, 01 Jan 2000 00:00:00 GMT"
		1113	],
		1114	"x-content-type-options": [
		1115	"nosniff"
		1116	],
		1117	"cache-control": [
		1118	"no-store"
		1119	],
		1120	"content-type": [
		1121	"application/json"
		1122	],
		1123	"x-xss-protection": [
		1124	"1; mode=block"
		1125	],
		1126	"transfer-encoding": [
		1127	"chunked"
		1128	],
		1129	"date": [
		1130	"Sat, 25 Jan 2020 06:01:14 GMT"
		1131	]
		1132	},
		1133	"body": {
		1134	"string": "{\"result\":{\"diffid\":19601,\"phid\":\"PHID-DIFF-burakyhnzac52zcbjn2l\",\"uri\":\"https:\\/\\/phab.mercurial-scm.org\\/differential\\/diff\\/19601\\/\"},\"error_code\":null,\"error_info\":null}"
		1135	}
		1136	},
		1137	"request": {
		1138	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22bookmark%22%3A+null%2C+%22branch%22%3A+%22default%22%2C+%22changes%22%3A+%7B%22bin%22%3A+%7B%22addLines%22%3A+0%2C+%22awayPaths%22%3A+%5B%5D%2C+%22commitHash%22%3A+null%2C+%22currentPath%22%3A+%22bin%22%2C+%22delLines%22%3A+0%2C+%22fileType%22%3A+1%2C+%22hunks%22%3A+%5B%5D%2C+%22metadata%22%3A+%7B%7D%2C+%22newProperties%22%3A+%7B%7D%2C+%22oldPath%22%3A+%22bin%22%2C+%22oldProperties%22%3A+%7B%22unix%3Afilemode%22%3A+%22100644%22%7D%2C+%22type%22%3A+3%7D%7D%2C+%22creationMethod%22%3A+%22phabsend%22%2C+%22lintStatus%22%3A+%22none%22%2C+%22repositoryPHID%22%3A+%22PHID-REPO-bvunnehri4u2isyr7bc3%22%2C+%22sourceControlBaseRevision%22%3A+%22d8d62a881b546814f012cef7c1bd0c438cc153e2%22%2C+%22sourceControlPath%22%3A+%22%2F%22%2C+%22sourceControlSystem%22%3A+%22hg%22%2C+%22sourceMachine%22%3A+%22%22%2C+%22sourcePath%22%3A+%22%2F%22%2C+%22unitStatus%22%3A+%22none%22%7D",
		1139	"method": "POST",
		1140	"headers": {
		1141	"content-type": [
		1142	"application/x-www-form-urlencoded"
		1143	],
		1144	"user-agent": [
		1145	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1146	],
		1147	"content-length": [
		1148	"991"
		1149	],
		1150	"host": [
		1151	"phab.mercurial-scm.org"
		1152	],
		1153	"accept": [
		1154	"application/mercurial-0.1"
		1155	]
		1156	},
		1157	"uri": "https://phab.mercurial-scm.org//api/differential.creatediff"
		1158	}
		1159	},
		1160	{
		1161	"response": {
		1162	"status": {
		1163	"message": "OK",
		1164	"code": 200
		1165	},
		1166	"headers": {
		1167	"strict-transport-security": [
		1168	"max-age=0; includeSubdomains; preload"
		1169	],
		1170	"server": [
		1171	"Apache/2.4.10 (Debian)"
		1172	],
		1173	"referrer-policy": [
		1174	"no-referrer"
		1175	],
		1176	"x-frame-options": [
		1177	"Deny"
		1178	],
		1179	"expires": [
		1180	"Sat, 01 Jan 2000 00:00:00 GMT"
		1181	],
		1182	"x-content-type-options": [
		1183	"nosniff"
		1184	],
		1185	"cache-control": [
		1186	"no-store"
		1187	],
		1188	"content-type": [
		1189	"application/json"
		1190	],
		1191	"x-xss-protection": [
		1192	"1; mode=block"
		1193	],
		1194	"transfer-encoding": [
		1195	"chunked"
		1196	],
		1197	"date": [
		1198	"Sat, 25 Jan 2020 06:01:14 GMT"
		1199	]
		1200	},
		1201	"body": {
		1202	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1203	}
		1204	},
		1205	"request": {
		1206	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22date%5C%22%3A+%5C%220+0%5C%22%2C+%5C%22node%5C%22%3A+%5C%22af55645b2e292f3168e993e74356af15dee0abdb%5C%22%2C+%5C%22parent%5C%22%3A+%5C%22d8d62a881b546814f012cef7c1bd0c438cc153e2%5C%22%2C+%5C%22user%5C%22%3A+%5C%22test%5C%22%7D%22%2C+%22diff_id%22%3A+19601%2C+%22name%22%3A+%22hg%3Ameta%22%7D",
		1207	"method": "POST",
		1208	"headers": {
		1209	"content-type": [
		1210	"application/x-www-form-urlencoded"
		1211	],
		1212	"user-agent": [
		1213	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1214	],
		1215	"content-length": [
		1216	"482"
		1217	],
		1218	"host": [
		1219	"phab.mercurial-scm.org"
		1220	],
		1221	"accept": [
		1222	"application/mercurial-0.1"
		1223	]
		1224	},
		1225	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1226	}
		1227	},
		1228	{
		1229	"response": {
		1230	"status": {
		1231	"message": "OK",
		1232	"code": 200
		1233	},
		1234	"headers": {
		1235	"strict-transport-security": [
		1236	"max-age=0; includeSubdomains; preload"
		1237	],
		1238	"server": [
		1239	"Apache/2.4.10 (Debian)"
		1240	],
		1241	"referrer-policy": [
		1242	"no-referrer"
		1243	],
		1244	"x-frame-options": [
		1245	"Deny"
		1246	],
		1247	"expires": [
		1248	"Sat, 01 Jan 2000 00:00:00 GMT"
		1249	],
		1250	"x-content-type-options": [
		1251	"nosniff"
		1252	],
		1253	"cache-control": [
		1254	"no-store"
		1255	],
		1256	"content-type": [
		1257	"application/json"
		1258	],
		1259	"x-xss-protection": [
		1260	"1; mode=block"
		1261	],
		1262	"transfer-encoding": [
		1263	"chunked"
		1264	],
		1265	"date": [
		1266	"Sat, 25 Jan 2020 06:01:15 GMT"
		1267	]
		1268	},
		1269	"body": {
		1270	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1271	}
		1272	},
		1273	"request": {
		1274	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22af55645b2e292f3168e993e74356af15dee0abdb%5C%22%3A+%7B%5C%22author%5C%22%3A+%5C%22test%5C%22%2C+%5C%22authorEmail%5C%22%3A+%5C%22test%5C%22%2C+%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22commit%5C%22%3A+%5C%22af55645b2e292f3168e993e74356af15dee0abdb%5C%22%2C+%5C%22parents%5C%22%3A+%5B%5C%22d8d62a881b546814f012cef7c1bd0c438cc153e2%5C%22%5D%2C+%5C%22time%5C%22%3A+0%7D%7D%22%2C+%22diff_id%22%3A+19601%2C+%22name%22%3A+%22local%3Acommits%22%7D",
		1275	"method": "POST",
		1276	"headers": {
		1277	"content-type": [
		1278	"application/x-www-form-urlencoded"
		1279	],
		1280	"user-agent": [
		1281	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1282	],
		1283	"content-length": [
		1284	"594"
		1285	],
		1286	"host": [
		1287	"phab.mercurial-scm.org"
		1288	],
		1289	"accept": [
		1290	"application/mercurial-0.1"
		1291	]
		1292	},
		1293	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1294	}
		1295	},
		1296	{
		1297	"response": {
		1298	"status": {
		1299	"message": "OK",
		1300	"code": 200
		1301	},
		1302	"headers": {
		1303	"strict-transport-security": [
		1304	"max-age=0; includeSubdomains; preload"
		1305	],
		1306	"server": [
		1307	"Apache/2.4.10 (Debian)"
		1308	],
		1309	"referrer-policy": [
		1310	"no-referrer"
		1311	],
		1312	"x-frame-options": [
		1313	"Deny"
		1314	],
		1315	"expires": [
		1316	"Sat, 01 Jan 2000 00:00:00 GMT"
		1317	],
		1318	"x-content-type-options": [
		1319	"nosniff"
		1320	],
		1321	"cache-control": [
		1322	"no-store"
		1323	],
		1324	"content-type": [
		1325	"application/json"
		1326	],
		1327	"x-xss-protection": [
		1328	"1; mode=block"
		1329	],
		1330	"transfer-encoding": [
		1331	"chunked"
		1332	],
		1333	"date": [
		1334	"Sat, 25 Jan 2020 06:01:15 GMT"
		1335	]
		1336	},
		1337	"body": {
		1338	"string": "{\"result\":{\"errors\":[],\"fields\":{\"title\":\"remove binary\"},\"revisionIDFieldInfo\":{\"value\":null,\"validDomain\":\"https:\\/\\/phab.mercurial-scm.org\"},\"transactions\":[{\"type\":\"title\",\"value\":\"remove binary\"}]},\"error_code\":null,\"error_info\":null}"
		1339	}
		1340	},
		1341	"request": {
		1342	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22corpus%22%3A+%22remove+binary%22%7D",
		1343	"method": "POST",
		1344	"headers": {
		1345	"content-type": [
		1346	"application/x-www-form-urlencoded"
		1347	],
		1348	"user-agent": [
		1349	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1350	],
		1351	"content-length": [
		1352	"158"
		1353	],
		1354	"host": [
		1355	"phab.mercurial-scm.org"
		1356	],
		1357	"accept": [
		1358	"application/mercurial-0.1"
		1359	]
		1360	},
		1361	"uri": "https://phab.mercurial-scm.org//api/differential.parsecommitmessage"
		1362	}
		1363	},
		1364	{
		1365	"response": {
		1366	"status": {
		1367	"message": "OK",
		1368	"code": 200
		1369	},
		1370	"headers": {
		1371	"strict-transport-security": [
		1372	"max-age=0; includeSubdomains; preload"
		1373	],
		1374	"server": [
		1375	"Apache/2.4.10 (Debian)"
		1376	],
		1377	"referrer-policy": [
		1378	"no-referrer"
		1379	],
		1380	"x-frame-options": [
		1381	"Deny"
		1382	],
		1383	"expires": [
		1384	"Sat, 01 Jan 2000 00:00:00 GMT"
		1385	],
		1386	"x-content-type-options": [
		1387	"nosniff"
		1388	],
		1389	"cache-control": [
		1390	"no-store"
		1391	],
		1392	"content-type": [
		1393	"application/json"
		1394	],
		1395	"x-xss-protection": [
		1396	"1; mode=block"
		1397	],
		1398	"transfer-encoding": [
		1399	"chunked"
		1400	],
		1401	"date": [
		1402	"Sat, 25 Jan 2020 06:01:16 GMT"
		1403	]
		1404	},
		1405	"body": {
		1406	"string": "{\"result\":{\"object\":{\"id\":8009,\"phid\":\"PHID-DREV-dhu2sy4tbldt4npi6sm7\"},\"transactions\":[{\"phid\":\"PHID-XACT-DREV-bj3vveste6uhvwa\"},{\"phid\":\"PHID-XACT-DREV-nh6m26vnt2lglxa\"},{\"phid\":\"PHID-XACT-DREV-qpaic5oz5gjiyac\"},{\"phid\":\"PHID-XACT-DREV-2e4pylpz72lnq4u\"},{\"phid\":\"PHID-XACT-DREV-4ajvkrw3bwabrxb\"},{\"phid\":\"PHID-XACT-DREV-xs75m6gczvk4fbb\"}]},\"error_code\":null,\"error_info\":null}"
		1407	}
		1408	},
		1409	"request": {
		1410	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22transactions%22%3A+%5B%7B%22type%22%3A+%22update%22%2C+%22value%22%3A+%22PHID-DIFF-burakyhnzac52zcbjn2l%22%7D%2C+%7B%22type%22%3A+%22parents.set%22%2C+%22value%22%3A+%5B%22PHID-DREV-q5cr6ap6pwfczhlhjrmv%22%5D%7D%2C+%7B%22type%22%3A+%22title%22%2C+%22value%22%3A+%22remove+binary%22%7D%5D%7D",
		1411	"method": "POST",
		1412	"headers": {
		1413	"content-type": [
		1414	"application/x-www-form-urlencoded"
		1415	],
		1416	"user-agent": [
		1417	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1418	],
		1419	"content-length": [
		1420	"413"
		1421	],
		1422	"host": [
		1423	"phab.mercurial-scm.org"
		1424	],
		1425	"accept": [
		1426	"application/mercurial-0.1"
		1427	]
		1428	},
		1429	"uri": "https://phab.mercurial-scm.org//api/differential.revision.edit"
		1430	}
		1431	},
		1432	{
		1433	"response": {
		1434	"status": {
		1435	"message": "OK",
		1436	"code": 200
		1437	},
		1438	"headers": {
		1439	"strict-transport-security": [
		1440	"max-age=0; includeSubdomains; preload"
		1441	],
		1442	"server": [
		1443	"Apache/2.4.10 (Debian)"
		1444	],
		1445	"referrer-policy": [
		1446	"no-referrer"
		1447	],
		1448	"x-frame-options": [
		1449	"Deny"
		1450	],
		1451	"expires": [
		1452	"Sat, 01 Jan 2000 00:00:00 GMT"
		1453	],
		1454	"x-content-type-options": [
		1455	"nosniff"
		1456	],
		1457	"cache-control": [
		1458	"no-store"
		1459	],
		1460	"content-type": [
		1461	"application/json"
		1462	],
		1463	"x-xss-protection": [
		1464	"1; mode=block"
		1465	],
		1466	"transfer-encoding": [
		1467	"chunked"
		1468	],
		1469	"date": [
		1470	"Sat, 25 Jan 2020 06:01:17 GMT"
		1471	]
		1472	},
		1473	"body": {
		1474	"string": "{\"result\":[{\"id\":\"8009\",\"phid\":\"PHID-DREV-dhu2sy4tbldt4npi6sm7\",\"title\":\"remove binary\",\"uri\":\"https:\\/\\/phab.mercurial-scm.org\\/D8009\",\"dateCreated\":\"1579932076\",\"dateModified\":\"1579932076\",\"authorPHID\":\"PHID-USER-tzhaient733lwrlbcag5\",\"status\":\"0\",\"statusName\":\"Needs Review\",\"properties\":{\"draft.broadcast\":true,\"lines.added\":0,\"lines.removed\":0},\"branch\":\"default\",\"summary\":\"\",\"testPlan\":\"\",\"lineCount\":\"0\",\"activeDiffPHID\":\"PHID-DIFF-burakyhnzac52zcbjn2l\",\"diffs\":[\"19601\"],\"commits\":[],\"reviewers\":{\"PHID-PROJ-3dvcxzznrjru2xmmses3\":\"PHID-PROJ-3dvcxzznrjru2xmmses3\"},\"ccs\":[\"PHID-USER-q42dn7cc3donqriafhjx\"],\"hashes\":[[\"hgcm\",\"\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\"]],\"auxiliary\":{\"phabricator:projects\":[],\"phabricator:depends-on\":[\"PHID-DREV-q5cr6ap6pwfczhlhjrmv\"]},\"repositoryPHID\":\"PHID-REPO-bvunnehri4u2isyr7bc3\",\"sourcePath\":\"\\/\"},{\"id\":\"8008\",\"phid\":\"PHID-DREV-q5cr6ap6pwfczhlhjrmv\",\"title\":\"modify binary\",\"uri\":\"https:\\/\\/phab.mercurial-scm.org\\/D8008\",\"dateCreated\":\"1579932073\",\"dateModified\":\"1579932076\",\"authorPHID\":\"PHID-USER-tzhaient733lwrlbcag5\",\"status\":\"0\",\"statusName\":\"Needs Review\",\"properties\":{\"draft.broadcast\":true,\"lines.added\":0,\"lines.removed\":0},\"branch\":\"default\",\"summary\":\"\",\"testPlan\":\"\",\"lineCount\":\"0\",\"activeDiffPHID\":\"PHID-DIFF-wdmlzkf4huoiqpl4vbsr\",\"diffs\":[\"19600\"],\"commits\":[],\"reviewers\":{\"PHID-PROJ-3dvcxzznrjru2xmmses3\":\"PHID-PROJ-3dvcxzznrjru2xmmses3\"},\"ccs\":[\"PHID-USER-q42dn7cc3donqriafhjx\"],\"hashes\":[[\"hgcm\",\"\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\"]],\"auxiliary\":{\"phabricator:projects\":[],\"phabricator:depends-on\":[\"PHID-DREV-477vjqq7vbddmjluy2cd\"]},\"repositoryPHID\":\"PHID-REPO-bvunnehri4u2isyr7bc3\",\"sourcePath\":\"\\/\"},{\"id\":\"8007\",\"phid\":\"PHID-DREV-477vjqq7vbddmjluy2cd\",\"title\":\"add binary\",\"uri\":\"https:\\/\\/phab.mercurial-scm.org\\/D8007\",\"dateCreated\":\"1579932068\",\"dateModified\":\"1579932073\",\"authorPHID\":\"PHID-USER-tzhaient733lwrlbcag5\",\"status\":\"0\",\"statusName\":\"Needs Review\",\"properties\":{\"draft.broadcast\":true,\"lines.added\":0,\"lines.removed\":0},\"branch\":\"default\",\"summary\":\"\",\"testPlan\":\"\",\"lineCount\":\"0\",\"activeDiffPHID\":\"PHID-DIFF-uvk7qaq6iglk4wgk2lxb\",\"diffs\":[\"19599\"],\"commits\":[],\"reviewers\":{\"PHID-PROJ-3dvcxzznrjru2xmmses3\":\"PHID-PROJ-3dvcxzznrjru2xmmses3\"},\"ccs\":[\"PHID-USER-q42dn7cc3donqriafhjx\"],\"hashes\":[[\"hgcm\",\"\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\"]],\"auxiliary\":{\"phabricator:projects\":[],\"phabricator:depends-on\":[]},\"repositoryPHID\":\"PHID-REPO-bvunnehri4u2isyr7bc3\",\"sourcePath\":\"\\/\"}],\"error_code\":null,\"error_info\":null}"
		1475	}
		1476	},
		1477	"request": {
		1478	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22ids%22%3A+%5B8007%2C+8008%2C+8009%5D%7D",
		1479	"method": "POST",
		1480	"headers": {
		1481	"content-type": [
		1482	"application/x-www-form-urlencoded"
		1483	],
		1484	"user-agent": [
		1485	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1486	],
		1487	"content-length": [
		1488	"162"
		1489	],
		1490	"host": [
		1491	"phab.mercurial-scm.org"
		1492	],
		1493	"accept": [
		1494	"application/mercurial-0.1"
		1495	]
		1496	},
		1497	"uri": "https://phab.mercurial-scm.org//api/differential.query"
		1498	}
		1499	},
		1500	{
		1501	"response": {
		1502	"status": {
		1503	"message": "OK",
		1504	"code": 200
		1505	},
		1506	"headers": {
		1507	"strict-transport-security": [
		1508	"max-age=0; includeSubdomains; preload"
		1509	],
		1510	"server": [
		1511	"Apache/2.4.10 (Debian)"
		1512	],
		1513	"referrer-policy": [
		1514	"no-referrer"
		1515	],
		1516	"x-frame-options": [
		1517	"Deny"
		1518	],
		1519	"expires": [
		1520	"Sat, 01 Jan 2000 00:00:00 GMT"
		1521	],
		1522	"x-content-type-options": [
		1523	"nosniff"
		1524	],
		1525	"cache-control": [
		1526	"no-store"
		1527	],
		1528	"content-type": [
		1529	"application/json"
		1530	],
		1531	"x-xss-protection": [
		1532	"1; mode=block"
		1533	],
		1534	"transfer-encoding": [
		1535	"chunked"
		1536	],
		1537	"date": [
		1538	"Sat, 25 Jan 2020 06:01:17 GMT"
		1539	]
		1540	},
		1541	"body": {
		1542	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1543	}
		1544	},
		1545	"request": {
		1546	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22date%5C%22%3A+%5C%220+0%5C%22%2C+%5C%22node%5C%22%3A+%5C%22b8139fbb4a579a69dccd906a1a8bf34ba2b885a3%5C%22%2C+%5C%22parent%5C%22%3A+%5C%221849d7828727a28e14c589323e4f8c9a1c8d2816%5C%22%2C+%5C%22user%5C%22%3A+%5C%22test%5C%22%7D%22%2C+%22diff_id%22%3A+19599%2C+%22name%22%3A+%22hg%3Ameta%22%7D",
		1547	"method": "POST",
		1548	"headers": {
		1549	"content-type": [
		1550	"application/x-www-form-urlencoded"
		1551	],
		1552	"user-agent": [
		1553	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1554	],
		1555	"content-length": [
		1556	"482"
		1557	],
		1558	"host": [
		1559	"phab.mercurial-scm.org"
		1560	],
		1561	"accept": [
		1562	"application/mercurial-0.1"
		1563	]
		1564	},
		1565	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1566	}
		1567	},
		1568	{
		1569	"response": {
		1570	"status": {
		1571	"message": "OK",
		1572	"code": 200
		1573	},
		1574	"headers": {
		1575	"strict-transport-security": [
		1576	"max-age=0; includeSubdomains; preload"
		1577	],
		1578	"server": [
		1579	"Apache/2.4.10 (Debian)"
		1580	],
		1581	"referrer-policy": [
		1582	"no-referrer"
		1583	],
		1584	"x-frame-options": [
		1585	"Deny"
		1586	],
		1587	"expires": [
		1588	"Sat, 01 Jan 2000 00:00:00 GMT"
		1589	],
		1590	"x-content-type-options": [
		1591	"nosniff"
		1592	],
		1593	"cache-control": [
		1594	"no-store"
		1595	],
		1596	"content-type": [
		1597	"application/json"
		1598	],
		1599	"x-xss-protection": [
		1600	"1; mode=block"
		1601	],
		1602	"transfer-encoding": [
		1603	"chunked"
		1604	],
		1605	"date": [
		1606	"Sat, 25 Jan 2020 06:01:18 GMT"
		1607	]
		1608	},
		1609	"body": {
		1610	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1611	}
		1612	},
		1613	"request": {
		1614	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22b8139fbb4a579a69dccd906a1a8bf34ba2b885a3%5C%22%3A+%7B%5C%22author%5C%22%3A+%5C%22test%5C%22%2C+%5C%22authorEmail%5C%22%3A+%5C%22test%5C%22%2C+%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22commit%5C%22%3A+%5C%22b8139fbb4a579a69dccd906a1a8bf34ba2b885a3%5C%22%2C+%5C%22parents%5C%22%3A+%5B%5C%221849d7828727a28e14c589323e4f8c9a1c8d2816%5C%22%5D%2C+%5C%22time%5C%22%3A+0%7D%7D%22%2C+%22diff_id%22%3A+19599%2C+%22name%22%3A+%22local%3Acommits%22%7D",
		1615	"method": "POST",
		1616	"headers": {
		1617	"content-type": [
		1618	"application/x-www-form-urlencoded"
		1619	],
		1620	"user-agent": [
		1621	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1622	],
		1623	"content-length": [
		1624	"594"
		1625	],
		1626	"host": [
		1627	"phab.mercurial-scm.org"
		1628	],
		1629	"accept": [
		1630	"application/mercurial-0.1"
		1631	]
		1632	},
		1633	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1634	}
		1635	},
		1636	{
		1637	"response": {
		1638	"status": {
		1639	"message": "OK",
		1640	"code": 200
		1641	},
		1642	"headers": {
		1643	"strict-transport-security": [
		1644	"max-age=0; includeSubdomains; preload"
		1645	],
		1646	"server": [
		1647	"Apache/2.4.10 (Debian)"
		1648	],
		1649	"referrer-policy": [
		1650	"no-referrer"
		1651	],
		1652	"x-frame-options": [
		1653	"Deny"
		1654	],
		1655	"expires": [
		1656	"Sat, 01 Jan 2000 00:00:00 GMT"
		1657	],
		1658	"x-content-type-options": [
		1659	"nosniff"
		1660	],
		1661	"cache-control": [
		1662	"no-store"
		1663	],
		1664	"content-type": [
		1665	"application/json"
		1666	],
		1667	"x-xss-protection": [
		1668	"1; mode=block"
		1669	],
		1670	"transfer-encoding": [
		1671	"chunked"
		1672	],
		1673	"date": [
		1674	"Sat, 25 Jan 2020 06:01:19 GMT"
		1675	]
		1676	},
		1677	"body": {
		1678	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1679	}
		1680	},
		1681	"request": {
		1682	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22date%5C%22%3A+%5C%220+0%5C%22%2C+%5C%22node%5C%22%3A+%5C%22c88ce4c2d2ad6337b772bc093398f85858196eb5%5C%22%2C+%5C%22parent%5C%22%3A+%5C%22b8139fbb4a579a69dccd906a1a8bf34ba2b885a3%5C%22%2C+%5C%22user%5C%22%3A+%5C%22test%5C%22%7D%22%2C+%22diff_id%22%3A+19600%2C+%22name%22%3A+%22hg%3Ameta%22%7D",
		1683	"method": "POST",
		1684	"headers": {
		1685	"content-type": [
		1686	"application/x-www-form-urlencoded"
		1687	],
		1688	"user-agent": [
		1689	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1690	],
		1691	"content-length": [
		1692	"482"
		1693	],
		1694	"host": [
		1695	"phab.mercurial-scm.org"
		1696	],
		1697	"accept": [
		1698	"application/mercurial-0.1"
		1699	]
		1700	},
		1701	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1702	}
		1703	},
		1704	{
		1705	"response": {
		1706	"status": {
		1707	"message": "OK",
		1708	"code": 200
		1709	},
		1710	"headers": {
		1711	"strict-transport-security": [
		1712	"max-age=0; includeSubdomains; preload"
		1713	],
		1714	"server": [
		1715	"Apache/2.4.10 (Debian)"
		1716	],
		1717	"referrer-policy": [
		1718	"no-referrer"
		1719	],
		1720	"x-frame-options": [
		1721	"Deny"
		1722	],
		1723	"expires": [
		1724	"Sat, 01 Jan 2000 00:00:00 GMT"
		1725	],
		1726	"x-content-type-options": [
		1727	"nosniff"
		1728	],
		1729	"cache-control": [
		1730	"no-store"
		1731	],
		1732	"content-type": [
		1733	"application/json"
		1734	],
		1735	"x-xss-protection": [
		1736	"1; mode=block"
		1737	],
		1738	"transfer-encoding": [
		1739	"chunked"
		1740	],
		1741	"date": [
		1742	"Sat, 25 Jan 2020 06:01:19 GMT"
		1743	]
		1744	},
		1745	"body": {
		1746	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1747	}
		1748	},
		1749	"request": {
		1750	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22c88ce4c2d2ad6337b772bc093398f85858196eb5%5C%22%3A+%7B%5C%22author%5C%22%3A+%5C%22test%5C%22%2C+%5C%22authorEmail%5C%22%3A+%5C%22test%5C%22%2C+%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22commit%5C%22%3A+%5C%22c88ce4c2d2ad6337b772bc093398f85858196eb5%5C%22%2C+%5C%22parents%5C%22%3A+%5B%5C%22b8139fbb4a579a69dccd906a1a8bf34ba2b885a3%5C%22%5D%2C+%5C%22time%5C%22%3A+0%7D%7D%22%2C+%22diff_id%22%3A+19600%2C+%22name%22%3A+%22local%3Acommits%22%7D",
		1751	"method": "POST",
		1752	"headers": {
		1753	"content-type": [
		1754	"application/x-www-form-urlencoded"
		1755	],
		1756	"user-agent": [
		1757	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1758	],
		1759	"content-length": [
		1760	"594"
		1761	],
		1762	"host": [
		1763	"phab.mercurial-scm.org"
		1764	],
		1765	"accept": [
		1766	"application/mercurial-0.1"
		1767	]
		1768	},
		1769	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1770	}
		1771	},
		1772	{
		1773	"response": {
		1774	"status": {
		1775	"message": "OK",
		1776	"code": 200
		1777	},
		1778	"headers": {
		1779	"strict-transport-security": [
		1780	"max-age=0; includeSubdomains; preload"
		1781	],
		1782	"server": [
		1783	"Apache/2.4.10 (Debian)"
		1784	],
		1785	"referrer-policy": [
		1786	"no-referrer"
		1787	],
		1788	"x-frame-options": [
		1789	"Deny"
		1790	],
		1791	"expires": [
		1792	"Sat, 01 Jan 2000 00:00:00 GMT"
		1793	],
		1794	"x-content-type-options": [
		1795	"nosniff"
		1796	],
		1797	"cache-control": [
		1798	"no-store"
		1799	],
		1800	"content-type": [
		1801	"application/json"
		1802	],
		1803	"x-xss-protection": [
		1804	"1; mode=block"
		1805	],
		1806	"transfer-encoding": [
		1807	"chunked"
		1808	],
		1809	"date": [
		1810	"Sat, 25 Jan 2020 06:01:20 GMT"
		1811	]
		1812	},
		1813	"body": {
		1814	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1815	}
		1816	},
		1817	"request": {
		1818	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22date%5C%22%3A+%5C%220+0%5C%22%2C+%5C%22node%5C%22%3A+%5C%2275dbbc901145d7beb190197aa232f74540e5a9f3%5C%22%2C+%5C%22parent%5C%22%3A+%5C%22c88ce4c2d2ad6337b772bc093398f85858196eb5%5C%22%2C+%5C%22user%5C%22%3A+%5C%22test%5C%22%7D%22%2C+%22diff_id%22%3A+19601%2C+%22name%22%3A+%22hg%3Ameta%22%7D",
		1819	"method": "POST",
		1820	"headers": {
		1821	"content-type": [
		1822	"application/x-www-form-urlencoded"
		1823	],
		1824	"user-agent": [
		1825	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1826	],
		1827	"content-length": [
		1828	"482"
		1829	],
		1830	"host": [
		1831	"phab.mercurial-scm.org"
		1832	],
		1833	"accept": [
		1834	"application/mercurial-0.1"
		1835	]
		1836	},
		1837	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1838	}
		1839	},
		1840	{
		1841	"response": {
		1842	"status": {
		1843	"message": "OK",
		1844	"code": 200
		1845	},
		1846	"headers": {
		1847	"strict-transport-security": [
		1848	"max-age=0; includeSubdomains; preload"
		1849	],
		1850	"server": [
		1851	"Apache/2.4.10 (Debian)"
		1852	],
		1853	"referrer-policy": [
		1854	"no-referrer"
		1855	],
		1856	"x-frame-options": [
		1857	"Deny"
		1858	],
		1859	"expires": [
		1860	"Sat, 01 Jan 2000 00:00:00 GMT"
		1861	],
		1862	"x-content-type-options": [
		1863	"nosniff"
		1864	],
		1865	"cache-control": [
		1866	"no-store"
		1867	],
		1868	"content-type": [
		1869	"application/json"
		1870	],
		1871	"x-xss-protection": [
		1872	"1; mode=block"
		1873	],
		1874	"transfer-encoding": [
		1875	"chunked"
		1876	],
		1877	"date": [
		1878	"Sat, 25 Jan 2020 06:01:21 GMT"
		1879	]
		1880	},
		1881	"body": {
		1882	"string": "{\"result\":null,\"error_code\":null,\"error_info\":null}"
		1883	}
		1884	},
		1885	"request": {
		1886	"body": "output=json&__conduit__=1&params=%7B%22__conduit__%22%3A+%7B%22token%22%3A+%22cli-hahayouwish%22%7D%2C+%22data%22%3A+%22%7B%5C%2275dbbc901145d7beb190197aa232f74540e5a9f3%5C%22%3A+%7B%5C%22author%5C%22%3A+%5C%22test%5C%22%2C+%5C%22authorEmail%5C%22%3A+%5C%22test%5C%22%2C+%5C%22branch%5C%22%3A+%5C%22default%5C%22%2C+%5C%22commit%5C%22%3A+%5C%2275dbbc901145d7beb190197aa232f74540e5a9f3%5C%22%2C+%5C%22parents%5C%22%3A+%5B%5C%22c88ce4c2d2ad6337b772bc093398f85858196eb5%5C%22%5D%2C+%5C%22time%5C%22%3A+0%7D%7D%22%2C+%22diff_id%22%3A+19601%2C+%22name%22%3A+%22local%3Acommits%22%7D",
		1887	"method": "POST",
		1888	"headers": {
		1889	"content-type": [
		1890	"application/x-www-form-urlencoded"
		1891	],
		1892	"user-agent": [
		1893	"mercurial/proto-1.0 (Mercurial 5.3rc1+3-624fe53ce1e7+20200124)"
		1894	],
		1895	"content-length": [
		1896	"594"
		1897	],
		1898	"host": [
		1899	"phab.mercurial-scm.org"
		1900	],
		1901	"accept": [
		1902	"application/mercurial-0.1"
		1903	]
		1904	},
		1905	"uri": "https://phab.mercurial-scm.org//api/differential.setdiffproperty"
		1906	}
		1907	}
		1908	]
		1909	} No newline at end of file

hgext/phabricator.py

0 +3 -3

             # phabricator.py - simple Phabricator integration
             #
             # Copyright 2017 Facebook, Inc.
             #
             # This software may be used and distributed according to the terms of the
             # GNU General Public License version 2 or any later version.
             """simple Phabricator integration (EXPERIMENTAL)
             This extension provides a ``phabsend`` command which sends a stack of
             changesets to Phabricator, and a ``phabread`` command which prints a stack of
             revisions in a format suitable for :hg:`import`, and a ``phabupdate`` command
             to update statuses in batch.
             A "phabstatus" view for :hg:`show` is also provided; it displays status
             information of Phabricator differentials associated with unfinished
             changesets.
             By default, Phabricator requires ``Test Plan`` which might prevent some
             changeset from being sent. The requirement could be disabled by changing
             ``differential.require-test-plan-field`` config server side.
             Config::
                 [phabricator]
                 # Phabricator URL
                 url = https://phab.example.com/
                 # Repo callsign. If a repo has a URL https://$HOST/diffusion/FOO, then its
                 # callsign is "FOO".
                 callsign = FOO
                 # curl command to use. If not set (default), use builtin HTTP library to
                 # communicate. If set, use the specified curl command. This could be useful
                 # if you need to specify advanced options that is not easily supported by
                 # the internal library.
                 curlcmd = curl --connect-timeout 2 --retry 3 --silent
                 [auth]
                 example.schemes = https
                 example.prefix = phab.example.com
                 # API token. Get it from https://$HOST/conduit/login/
                 example.phabtoken = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
             """
             from __future__ import absolute_import
             import base64
             import contextlib
             import hashlib
             import itertools
             import json
             import mimetypes
             import operator
             import re
             from mercurial.node import bin, nullid
             from mercurial.i18n import _
             from mercurial.pycompat import getattr
             from mercurial.thirdparty import attr
             from mercurial import (
                 cmdutil,
                 context,
                 encoding,
                 error,
                 exthelper,
                 graphmod,
                 httpconnection as httpconnectionmod,
                 localrepo,
                 logcmdutil,
                 match,
                 mdiff,
                 obsutil,
                 parser,
                 patch,
                 phases,
                 pycompat,
                 scmutil,
                 smartset,
                 tags,
                 templatefilters,
                 templateutil,
                 url as urlmod,
                 util,
             )
             from mercurial.utils import (
                 procutil,
                 stringutil,
             )
             from . import show
             # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
             # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
             # be specifying the version(s) of Mercurial they are tested with, or
             # leave the attribute unspecified.
             testedwith = b'ships-with-hg-core'
             eh = exthelper.exthelper()
             cmdtable = eh.cmdtable
             command = eh.command
             configtable = eh.configtable
             templatekeyword = eh.templatekeyword
             uisetup = eh.finaluisetup
             # developer config: phabricator.batchsize
             eh.configitem(
                 b'phabricator', b'batchsize', default=12,
             )
             eh.configitem(
                 b'phabricator', b'callsign', default=None,
             )
             eh.configitem(
                 b'phabricator', b'curlcmd', default=None,
             )
             # developer config: phabricator.repophid
             eh.configitem(
                 b'phabricator', b'repophid', default=None,
             )
             eh.configitem(
                 b'phabricator', b'url', default=None,
             )
             eh.configitem(
                 b'phabsend', b'confirm', default=False,
             )
             colortable = {
                 b'phabricator.action.created': b'green',
                 b'phabricator.action.skipped': b'magenta',
                 b'phabricator.action.updated': b'magenta',
                 b'phabricator.desc': b'',
                 b'phabricator.drev': b'bold',
                 b'phabricator.node': b'',
                 b'phabricator.status.abandoned': b'magenta dim',
                 b'phabricator.status.accepted': b'green bold',
                 b'phabricator.status.closed': b'green',
                 b'phabricator.status.needsreview': b'yellow',
                 b'phabricator.status.needsrevision': b'red',
                 b'phabricator.status.changesplanned': b'red',
             }
             _VCR_FLAGS = [
                 (
                     b'',
                     b'test-vcr',
                     b'',
                     _(
                         b'Path to a vcr file. If nonexistent, will record a new vcr transcript'
                         b', otherwise will mock all http requests using the specified vcr file.'
                         b' (ADVANCED)'
                     ),
                 ),
             ]
             @eh.wrapfunction(localrepo, "loadhgrc")
             def _loadhgrc(orig, ui, wdirvfs, hgvfs, requirements):
                 """Load ``.arcconfig`` content into a ui instance on repository open.
                 """
                 result = False
                 arcconfig = {}
                 try:
                     # json.loads only accepts bytes from 3.6+
                     rawparams = encoding.unifromlocal(wdirvfs.read(b".arcconfig"))
                     # json.loads only returns unicode strings
                     arcconfig = pycompat.rapply(
                         lambda x: encoding.unitolocal(x)
                         if isinstance(x, pycompat.unicode)
                         else x,
                         pycompat.json_loads(rawparams),
                     )
                     result = True
                 except ValueError:
                     ui.warn(_(b"invalid JSON in %s\n") % wdirvfs.join(b".arcconfig"))
                 except IOError:
                     pass
                 cfg = util.sortdict()
                 if b"repository.callsign" in arcconfig:
                     cfg[(b"phabricator", b"callsign")] = arcconfig[b"repository.callsign"]
                 if b"phabricator.uri" in arcconfig:
                     cfg[(b"phabricator", b"url")] = arcconfig[b"phabricator.uri"]
                 if cfg:
                     ui.applyconfig(cfg, source=wdirvfs.join(b".arcconfig"))
                 return orig(ui, wdirvfs, hgvfs, requirements) or result  # Load .hg/hgrc
             def vcrcommand(name, flags, spec, helpcategory=None, optionalrepo=False):
                 fullflags = flags + _VCR_FLAGS
                 def hgmatcher(r1, r2):
                     if r1.uri != r2.uri or r1.method != r2.method:
                         return False
                     r1params = util.urlreq.parseqs(r1.body)
                     r2params = util.urlreq.parseqs(r2.body)
                     for key in r1params:
                         if key not in r2params:
                             return False
                         value = r1params[key][0]
                         # we want to compare json payloads without worrying about ordering
                         if value.startswith(b'{') and value.endswith(b'}'):
                             r1json = pycompat.json_loads(value)
                             r2json = pycompat.json_loads(r2params[key][0])
                             if r1json != r2json:
                                 return False
                         elif r2params[key][0] != value:
                             return False
                     return True
                 def sanitiserequest(request):
                     request.body = re.sub(
                         br'cli-[a-z0-9]+', br'cli-hahayouwish', request.body
                     )
                     return request
                 def sanitiseresponse(response):
                     if 'set-cookie' in response['headers']:
                         del response['headers']['set-cookie']
                     return response
                 def decorate(fn):
                     def inner(*args, **kwargs):
                         cassette = pycompat.fsdecode(kwargs.pop('test_vcr', None))
                         if cassette:
                             import hgdemandimport
                             with hgdemandimport.deactivated():
                                 import vcr as vcrmod
                                 import vcr.stubs as stubs
                                 vcr = vcrmod.VCR(
                                     serializer='json',
                                     before_record_request=sanitiserequest,
                                     before_record_response=sanitiseresponse,
                                     custom_patches=[
                                         (
                                             urlmod,
                                             'httpconnection',
                                             stubs.VCRHTTPConnection,
                                         ),
                                         (
                                             urlmod,
                                             'httpsconnection',
                                             stubs.VCRHTTPSConnection,
                                         ),
                                     ],
                                 )
                                 vcr.register_matcher('hgmatcher', hgmatcher)
                                 with vcr.use_cassette(cassette, match_on=['hgmatcher']):
                                     return fn(*args, **kwargs)
                         return fn(*args, **kwargs)
                     inner.__name__ = fn.__name__
                     inner.__doc__ = fn.__doc__
                     return command(
                         name,
                         fullflags,
                         spec,
                         helpcategory=helpcategory,
                         optionalrepo=optionalrepo,
                     )(inner)
                 return decorate
             def urlencodenested(params):
                 """like urlencode, but works with nested parameters.
                 For example, if params is {'a': ['b', 'c'], 'd': {'e': 'f'}}, it will be
                 flattened to {'a[0]': 'b', 'a[1]': 'c', 'd[e]': 'f'} and then passed to
                 urlencode. Note: the encoding is consistent with PHP's http_build_query.
                 """
                 flatparams = util.sortdict()
                 def process(prefix, obj):
                     if isinstance(obj, bool):
                         obj = {True: b'true', False: b'false'}[obj]  # Python -> PHP form
                     lister = lambda l: [(b'%d' % k, v) for k, v in enumerate(l)]
                     items = {list: lister, dict: lambda x: x.items()}.get(type(obj))
                     if items is None:
                         flatparams[prefix] = obj
                     else:
                         for k, v in items(obj):
                             if prefix:
                                 process(b'%s[%s]' % (prefix, k), v)
                             else:
                                 process(k, v)
                 process(b'', params)
                 return util.urlreq.urlencode(flatparams)
             def readurltoken(ui):
                 """return conduit url, token and make sure they exist
                 Currently read from [auth] config section. In the future, it might
                 make sense to read from .arcconfig and .arcrc as well.
                 """
                 url = ui.config(b'phabricator', b'url')
                 if not url:
                     raise error.Abort(
                         _(b'config %s.%s is required') % (b'phabricator', b'url')
                     )
                 res = httpconnectionmod.readauthforuri(ui, url, util.url(url).user)
                 token = None
                 if res:
                     group, auth = res
                     ui.debug(b"using auth.%s.* for authentication\n" % group)
                     token = auth.get(b'phabtoken')
                 if not token:
                     raise error.Abort(
                         _(b'Can\'t find conduit token associated to %s') % (url,)
                     )
                 return url, token
             def callconduit(ui, name, params):
                 """call Conduit API, params is a dict. return json.loads result, or None"""
                 host, token = readurltoken(ui)
                 url, authinfo = util.url(b'/'.join([host, b'api', name])).authinfo()
                 ui.debug(b'Conduit Call: %s %s\n' % (url, pycompat.byterepr(params)))
                 params = params.copy()
                 params[b'__conduit__'] = {
                     b'token': token,
                 }
                 rawdata = {
                     b'params': templatefilters.json(params),
                     b'output': b'json',
                     b'__conduit__': 1,
                 }
                 data = urlencodenested(rawdata)
                 curlcmd = ui.config(b'phabricator', b'curlcmd')
                 if curlcmd:
                     sin, sout = procutil.popen2(
                         b'%s -d @- %s' % (curlcmd, procutil.shellquote(url))
                     )
                     sin.write(data)
                     sin.close()
                     body = sout.read()
                 else:
                     urlopener = urlmod.opener(ui, authinfo)
                     request = util.urlreq.request(pycompat.strurl(url), data=data)
                     with contextlib.closing(urlopener.open(request)) as rsp:
                         body = rsp.read()
                 ui.debug(b'Conduit Response: %s\n' % body)
                 parsed = pycompat.rapply(
                     lambda x: encoding.unitolocal(x)
                     if isinstance(x, pycompat.unicode)
                     else x,
                     # json.loads only accepts bytes from py3.6+
                     pycompat.json_loads(encoding.unifromlocal(body)),
                 )
                 if parsed.get(b'error_code'):
                     msg = _(b'Conduit Error (%s): %s') % (
                         parsed[b'error_code'],
                         parsed[b'error_info'],
                     )
                     raise error.Abort(msg)
                 return parsed[b'result']
             @vcrcommand(b'debugcallconduit', [], _(b'METHOD'), optionalrepo=True)
             def debugcallconduit(ui, repo, name):
                 """call Conduit API
                 Call parameters are read from stdin as a JSON blob. Result will be written
                 to stdout as a JSON blob.
                 """
                 # json.loads only accepts bytes from 3.6+
                 rawparams = encoding.unifromlocal(ui.fin.read())
                 # json.loads only returns unicode strings
                 params = pycompat.rapply(
                     lambda x: encoding.unitolocal(x)
                     if isinstance(x, pycompat.unicode)
                     else x,
                     pycompat.json_loads(rawparams),
                 )
                 # json.dumps only accepts unicode strings
                 result = pycompat.rapply(
                     lambda x: encoding.unifromlocal(x) if isinstance(x, bytes) else x,
                     callconduit(ui, name, params),
                 )
                 s = json.dumps(result, sort_keys=True, indent=2, separators=(u',', u': '))
                 ui.write(b'%s\n' % encoding.unitolocal(s))
             def getrepophid(repo):
                 """given callsign, return repository PHID or None"""
                 # developer config: phabricator.repophid
                 repophid = repo.ui.config(b'phabricator', b'repophid')
                 if repophid:
                     return repophid
                 callsign = repo.ui.config(b'phabricator', b'callsign')
                 if not callsign:
                     return None
                 query = callconduit(
                     repo.ui,
                     b'diffusion.repository.search',
                     {b'constraints': {b'callsigns': [callsign]}},
                 )
                 if len(query[b'data']) == 0:
                     return None
                 repophid = query[b'data'][0][b'phid']
                 repo.ui.setconfig(b'phabricator', b'repophid', repophid)
                 return repophid
             _differentialrevisiontagre = re.compile(br'\AD([1-9][0-9]*)\Z')
             _differentialrevisiondescre = re.compile(
                 br'^Differential Revision:\s*(?P<url>(?:.*)D(?P<id>[1-9][0-9]*))$', re.M
             )
             def getoldnodedrevmap(repo, nodelist):
                 """find previous nodes that has been sent to Phabricator
                 return {node: (oldnode, Differential diff, Differential Revision ID)}
                 for node in nodelist with known previous sent versions, or associated
                 Differential Revision IDs. ``oldnode`` and ``Differential diff`` could
                 be ``None``.
                 Examines commit messages like "Differential Revision:" to get the
                 association information.
                 If such commit message line is not found, examines all precursors and their
                 tags. Tags with format like "D1234" are considered a match and the node
                 with that tag, and the number after "D" (ex. 1234) will be returned.
                 The ``old node``, if not None, is guaranteed to be the last diff of
                 corresponding Differential Revision, and exist in the repo.
                 """
                 unfi = repo.unfiltered()
                 has_node = unfi.changelog.index.has_node
                 result = {}  # {node: (oldnode?, lastdiff?, drev)}
                 toconfirm = {}  # {node: (force, {precnode}, drev)}
                 for node in nodelist:
                     ctx = unfi[node]
                     # For tags like "D123", put them into "toconfirm" to verify later
                     precnodes = list(obsutil.allpredecessors(unfi.obsstore, [node]))
                     for n in precnodes:
                         if has_node(n):
                             for tag in unfi.nodetags(n):
                                 m = _differentialrevisiontagre.match(tag)
                                 if m:
                                     toconfirm[node] = (0, set(precnodes), int(m.group(1)))
                                     break
                             else:
                                 continue  # move to next predecessor
                             break  # found a tag, stop
                     else:
                         # Check commit message
                         m = _differentialrevisiondescre.search(ctx.description())
                         if m:
                             toconfirm[node] = (1, set(precnodes), int(m.group('id')))
                 # Double check if tags are genuine by collecting all old nodes from
                 # Phabricator, and expect precursors overlap with it.
                 if toconfirm:
                     drevs = [drev for force, precs, drev in toconfirm.values()]
                     alldiffs = callconduit(
                         unfi.ui, b'differential.querydiffs', {b'revisionIDs': drevs}
                     )
                     getnode = lambda d: bin(getdiffmeta(d).get(b'node', b'')) or None
                     for newnode, (force, precset, drev) in toconfirm.items():
                         diffs = [
                             d for d in alldiffs.values() if int(d[b'revisionID']) == drev
                         ]
                         # "precursors" as known by Phabricator
                         phprecset = set(getnode(d) for d in diffs)
                         # Ignore if precursors (Phabricator and local repo) do not overlap,
                         # and force is not set (when commit message says nothing)
                         if not force and not bool(phprecset & precset):
                             tagname = b'D%d' % drev
                             tags.tag(
                                 repo,
                                 tagname,
                                 nullid,
                                 message=None,
                                 user=None,
                                 date=None,
                                 local=True,
                             )
                             unfi.ui.warn(
                                 _(
                                     b'D%d: local tag removed - does not match '
                                     b'Differential history\n'
                                 )
                                 % drev
                             )
                             continue
                         # Find the last node using Phabricator metadata, and make sure it
                         # exists in the repo
                         oldnode = lastdiff = None
                         if diffs:
                             lastdiff = max(diffs, key=lambda d: int(d[b'id']))
                             oldnode = getnode(lastdiff)
                             if oldnode and not has_node(oldnode):
                                 oldnode = None
                         result[newnode] = (oldnode, lastdiff, drev)
                 return result
             def getdrevmap(repo, revs):
                 """Return a dict mapping each rev in `revs` to their Differential Revision
                 ID or None.
                 """
                 result = {}
                 for rev in revs:
                     result[rev] = None
                     ctx = repo[rev]
                     # Check commit message
                     m = _differentialrevisiondescre.search(ctx.description())
                     if m:
                         result[rev] = int(m.group('id'))
                         continue
                     # Check tags
                     for tag in repo.nodetags(ctx.node()):
                         m = _differentialrevisiontagre.match(tag)
                         if m:
                             result[rev] = int(m.group(1))
                             break
                 return result
             def getdiff(ctx, diffopts):
                 """plain-text diff without header (user, commit message, etc)"""
                 output = util.stringio()
                 for chunk, _label in patch.diffui(
                     ctx.repo(), ctx.p1().node(), ctx.node(), None, opts=diffopts
                 ):
                     output.write(chunk)
                 return output.getvalue()
             class DiffChangeType(object):
                 ADD = 1
                 CHANGE = 2
                 DELETE = 3
                 MOVE_AWAY = 4
                 COPY_AWAY = 5
                 MOVE_HERE = 6
                 COPY_HERE = 7
                 MULTICOPY = 8
             class DiffFileType(object):
                 TEXT = 1
                 IMAGE = 2
                 BINARY = 3
             @attr.s
             class phabhunk(dict):
                 """Represents a Differential hunk, which is owned by a Differential change
                 """
                 oldOffset = attr.ib(default=0)  # camelcase-required
                 oldLength = attr.ib(default=0)  # camelcase-required
                 newOffset = attr.ib(default=0)  # camelcase-required
                 newLength = attr.ib(default=0)  # camelcase-required
                 corpus = attr.ib(default='')
                 # These get added to the phabchange's equivalents
                 addLines = attr.ib(default=0)  # camelcase-required
                 delLines = attr.ib(default=0)  # camelcase-required
             @attr.s
             class phabchange(object):
                 """Represents a Differential change, owns Differential hunks and owned by a
                 Differential diff.  Each one represents one file in a diff.
                 """
                 currentPath = attr.ib(default=None)  # camelcase-required
                 oldPath = attr.ib(default=None)  # camelcase-required
                 awayPaths = attr.ib(default=attr.Factory(list))  # camelcase-required
                 metadata = attr.ib(default=attr.Factory(dict))
                 oldProperties = attr.ib(default=attr.Factory(dict))  # camelcase-required
                 newProperties = attr.ib(default=attr.Factory(dict))  # camelcase-required
                 type = attr.ib(default=DiffChangeType.CHANGE)
                 fileType = attr.ib(default=DiffFileType.TEXT)  # camelcase-required
                 commitHash = attr.ib(default=None)  # camelcase-required
                 addLines = attr.ib(default=0)  # camelcase-required
                 delLines = attr.ib(default=0)  # camelcase-required
                 hunks = attr.ib(default=attr.Factory(list))
                 def copynewmetadatatoold(self):
                     for key in list(self.metadata.keys()):
                         newkey = key.replace(b'new:', b'old:')
                         self.metadata[newkey] = self.metadata[key]
                 def addoldmode(self, value):
                     self.oldProperties[b'unix:filemode'] = value
                 def addnewmode(self, value):
                     self.newProperties[b'unix:filemode'] = value
                 def addhunk(self, hunk):
                     if not isinstance(hunk, phabhunk):
                         raise error.Abort(b'phabchange.addhunk only takes phabhunks')
                     self.hunks.append(pycompat.byteskwargs(attr.asdict(hunk)))
                     # It's useful to include these stats since the Phab web UI shows them,
                     # and uses them to estimate how large a change a Revision is. Also used
                     # in email subjects for the [+++--] bit.
                     self.addLines += hunk.addLines
                     self.delLines += hunk.delLines
             @attr.s
             class phabdiff(object):
                 """Represents a Differential diff, owns Differential changes.  Corresponds
                 to a commit.
                 """
                 # Doesn't seem to be any reason to send this (output of uname -n)
                 sourceMachine = attr.ib(default=b'')  # camelcase-required
                 sourcePath = attr.ib(default=b'/')  # camelcase-required
                 sourceControlBaseRevision = attr.ib(default=b'0' * 40)  # camelcase-required
                 sourceControlPath = attr.ib(default=b'/')  # camelcase-required
                 sourceControlSystem = attr.ib(default=b'hg')  # camelcase-required
                 branch = attr.ib(default=b'default')
                 bookmark = attr.ib(default=None)
                 creationMethod = attr.ib(default=b'phabsend')  # camelcase-required
                 lintStatus = attr.ib(default=b'none')  # camelcase-required
                 unitStatus = attr.ib(default=b'none')  # camelcase-required
                 changes = attr.ib(default=attr.Factory(dict))
                 repositoryPHID = attr.ib(default=None)  # camelcase-required
                 def addchange(self, change):
                     if not isinstance(change, phabchange):
                         raise error.Abort(b'phabdiff.addchange only takes phabchanges')
                     self.changes[change.currentPath] = pycompat.byteskwargs(
                         attr.asdict(change)
                     )
             def maketext(pchange, ctx, fname):
                 """populate the phabchange for a text file"""
                 repo = ctx.repo()
                 fmatcher = match.exact([fname])
                 diffopts = mdiff.diffopts(git=True, context=32767)
                 _pfctx, _fctx, header, fhunks = next(
                     patch.diffhunks(repo, ctx.p1(), ctx, fmatcher, opts=diffopts)
                 )
                 for fhunk in fhunks:
                     (oldOffset, oldLength, newOffset, newLength), lines = fhunk
                     corpus = b''.join(lines[1:])
                     shunk = list(header)
                     shunk.extend(lines)
                     _mf, _mt, addLines, delLines, _hb = patch.diffstatsum(
                         patch.diffstatdata(util.iterlines(shunk))
                     )
                     pchange.addhunk(
                         phabhunk(
                             oldOffset,
                             oldLength,
                             newOffset,
                             newLength,
                             corpus,
                             addLines,
                             delLines,
                         )
                     )
             def uploadchunks(fctx, fphid):
                 """upload large binary files as separate chunks.
                 Phab requests chunking over 8MiB, and splits into 4MiB chunks
                 """
                 ui = fctx.repo().ui
                 chunks = callconduit(ui, b'file.querychunks', {b'filePHID': fphid})
                 with ui.makeprogress(
                     _(b'uploading file chunks'), unit=_(b'chunks'), total=len(chunks)
                 ) as progress:
                     for chunk in chunks:
                         progress.increment()
                         if chunk[b'complete']:
                             continue
                         bstart = int(chunk[b'byteStart'])
                         bend = int(chunk[b'byteEnd'])
                         callconduit(
                             ui,
                             b'file.uploadchunk',
                             {
                                 b'filePHID': fphid,
                                 b'byteStart': bstart,
                                 b'data': base64.b64encode(fctx.data()[bstart:bend]),
                                 b'dataEncoding': b'base64',
                             },
                         )
             def uploadfile(fctx):
                 """upload binary files to Phabricator"""
                 repo = fctx.repo()
                 ui = repo.ui
                 fname = fctx.path()
                 size = fctx.size()
                 fhash = pycompat.bytestr(hashlib.sha256(fctx.data()).hexdigest())
                 # an allocate call is required first to see if an upload is even required
                 # (Phab might already have it) and to determine if chunking is needed
                 allocateparams = {
                     b'name': fname,
                     b'contentLength': size,
                     b'contentHash': fhash,
                 }
                 filealloc = callconduit(ui, b'file.allocate', allocateparams)
                 fphid = filealloc[b'filePHID']
                 if filealloc[b'upload']:
                     ui.write(_(b'uploading %s\n') % bytes(fctx))
                     if not fphid:
                         uploadparams = {
                             b'name': fname,
                             b'data_base64': base64.b64encode(fctx.data()),
                         }
                         fphid = callconduit(ui, b'file.upload', uploadparams)
                     else:
                         uploadchunks(fctx, fphid)
                 else:
                     ui.debug(b'server already has %s\n' % bytes(fctx))
                 if not fphid:
                     raise error.Abort(b'Upload of %s failed.' % bytes(fctx))
                 return fphid
-            def addoldbinary(pchange, fctx, originalfname):
+            def addoldbinary(pchange, fctx):
                 """add the metadata for the previous version of a binary file to the
                 phabchange for the new version
                 """
-                oldfctx = fctx.p1()[originalfname]
+                oldfctx = fctx.p1()
                 if fctx.cmp(oldfctx):
                     # Files differ, add the old one
                     pchange.metadata[b'old:file:size'] = oldfctx.size()
                     mimeguess, _enc = mimetypes.guess_type(
                         encoding.unifromlocal(oldfctx.path())
                     )
                     if mimeguess:
                         pchange.metadata[b'old:file:mime-type'] = pycompat.bytestr(
                             mimeguess
                         )
                     fphid = uploadfile(oldfctx)
                     pchange.metadata[b'old:binary-phid'] = fphid
                 else:
                     # If it's left as IMAGE/BINARY web UI might try to display it
                     pchange.fileType = DiffFileType.TEXT
                     pchange.copynewmetadatatoold()
             def makebinary(pchange, fctx):
                 """populate the phabchange for a binary file"""
                 pchange.fileType = DiffFileType.BINARY
                 fphid = uploadfile(fctx)
                 pchange.metadata[b'new:binary-phid'] = fphid
                 pchange.metadata[b'new:file:size'] = fctx.size()
                 mimeguess, _enc = mimetypes.guess_type(encoding.unifromlocal(fctx.path()))
                 if mimeguess:
                     mimeguess = pycompat.bytestr(mimeguess)
                     pchange.metadata[b'new:file:mime-type'] = mimeguess
                     if mimeguess.startswith(b'image/'):
                         pchange.fileType = DiffFileType.IMAGE
             # Copied from mercurial/patch.py
             gitmode = {b'l': b'120000', b'x': b'100755', b'': b'100644'}
             def notutf8(fctx):
                 """detect non-UTF-8 text files since Phabricator requires them to be marked
                 as binary
                 """
                 try:
                     fctx.data().decode('utf-8')
                     if fctx.parents():
                         fctx.p1().data().decode('utf-8')
                     return False
                 except UnicodeDecodeError:
                     fctx.repo().ui.write(
                         _(b'file %s detected as non-UTF-8, marked as binary\n')
                         % fctx.path()
                     )
                     return True
             def addremoved(pdiff, ctx, removed):
                 """add removed files to the phabdiff. Shouldn't include moves"""
                 for fname in removed:
                     pchange = phabchange(
                         currentPath=fname, oldPath=fname, type=DiffChangeType.DELETE
                     )
                     pchange.addoldmode(gitmode[ctx.p1()[fname].flags()])
                     fctx = ctx.p1()[fname]
                     if not (fctx.isbinary() or notutf8(fctx)):
                         maketext(pchange, ctx, fname)
                     pdiff.addchange(pchange)
             def addmodified(pdiff, ctx, modified):
                 """add modified files to the phabdiff"""
                 for fname in modified:
                     fctx = ctx[fname]
                     pchange = phabchange(currentPath=fname, oldPath=fname)
                     filemode = gitmode[ctx[fname].flags()]
                     originalmode = gitmode[ctx.p1()[fname].flags()]
                     if filemode != originalmode:
                         pchange.addoldmode(originalmode)
                         pchange.addnewmode(filemode)
                     if fctx.isbinary() or notutf8(fctx):
                         makebinary(pchange, fctx)
-                        addoldbinary(pchange, fctx, fname)
+                        addoldbinary(pchange, fctx)
                     else:
                         maketext(pchange, ctx, fname)
                     pdiff.addchange(pchange)
             def addadded(pdiff, ctx, added, removed):
                 """add file adds to the phabdiff, both new files and copies/moves"""
                 # Keep track of files that've been recorded as moved/copied, so if there are
                 # additional copies we can mark them (moves get removed from removed)
                 copiedchanges = {}
                 movedchanges = {}
                 for fname in added:
                     fctx = ctx[fname]
                     pchange = phabchange(currentPath=fname)
                     filemode = gitmode[ctx[fname].flags()]
                     renamed = fctx.renamed()
                     if renamed:
                         originalfname = renamed[0]
                         originalmode = gitmode[ctx.p1()[originalfname].flags()]
                         pchange.oldPath = originalfname
                         if originalfname in removed:
                             origpchange = phabchange(
                                 currentPath=originalfname,
                                 oldPath=originalfname,
                                 type=DiffChangeType.MOVE_AWAY,
                                 awayPaths=[fname],
                             )
                             movedchanges[originalfname] = origpchange
                             removed.remove(originalfname)
                             pchange.type = DiffChangeType.MOVE_HERE
                         elif originalfname in movedchanges:
                             movedchanges[originalfname].type = DiffChangeType.MULTICOPY
                             movedchanges[originalfname].awayPaths.append(fname)
                             pchange.type = DiffChangeType.COPY_HERE
                         else:  # pure copy
                             if originalfname not in copiedchanges:
                                 origpchange = phabchange(
                                     currentPath=originalfname, type=DiffChangeType.COPY_AWAY
                                 )
                                 copiedchanges[originalfname] = origpchange
                             else:
                                 origpchange = copiedchanges[originalfname]
                             origpchange.awayPaths.append(fname)
                             pchange.type = DiffChangeType.COPY_HERE
                         if filemode != originalmode:
                             pchange.addoldmode(originalmode)
                             pchange.addnewmode(filemode)
                     else:  # Brand-new file
                         pchange.addnewmode(gitmode[fctx.flags()])
                         pchange.type = DiffChangeType.ADD
                     if fctx.isbinary() or notutf8(fctx):
                         makebinary(pchange, fctx)
                         if renamed:
                             addoldbinary(pchange, fctx, originalfname)
                     else:
                         maketext(pchange, ctx, fname)
                     pdiff.addchange(pchange)
                 for _path, copiedchange in copiedchanges.items():
                     pdiff.addchange(copiedchange)
                 for _path, movedchange in movedchanges.items():
                     pdiff.addchange(movedchange)
             def creatediff(ctx):
                 """create a Differential Diff"""
                 repo = ctx.repo()
                 repophid = getrepophid(repo)
                 # Create a "Differential Diff" via "differential.creatediff" API
                 pdiff = phabdiff(
                     sourceControlBaseRevision=b'%s' % ctx.p1().hex(),
                     branch=b'%s' % ctx.branch(),
                 )
                 modified, added, removed, _d, _u, _i, _c = ctx.p1().status(ctx)
                 # addadded will remove moved files from removed, so addremoved won't get
                 # them
                 addadded(pdiff, ctx, added, removed)
                 addmodified(pdiff, ctx, modified)
                 addremoved(pdiff, ctx, removed)
                 if repophid:
                     pdiff.repositoryPHID = repophid
                 diff = callconduit(
                     repo.ui,
                     b'differential.creatediff',
                     pycompat.byteskwargs(attr.asdict(pdiff)),
                 )
                 if not diff:
                     raise error.Abort(_(b'cannot create diff for %s') % ctx)
                 return diff
             def writediffproperties(ctx, diff):
                 """write metadata to diff so patches could be applied losslessly"""
                 # creatediff returns with a diffid but query returns with an id
                 diffid = diff.get(b'diffid', diff.get(b'id'))
                 params = {
                     b'diff_id': diffid,
                     b'name': b'hg:meta',
                     b'data': templatefilters.json(
                         {
                             b'user': ctx.user(),
                             b'date': b'%d %d' % ctx.date(),
                             b'branch': ctx.branch(),
                             b'node': ctx.hex(),
                             b'parent': ctx.p1().hex(),
                         }
                     ),
                 }
                 callconduit(ctx.repo().ui, b'differential.setdiffproperty', params)
                 params = {
                     b'diff_id': diffid,
                     b'name': b'local:commits',
                     b'data': templatefilters.json(
                         {
                             ctx.hex(): {
                                 b'author': stringutil.person(ctx.user()),
                                 b'authorEmail': stringutil.email(ctx.user()),
                                 b'time': int(ctx.date()[0]),
                                 b'commit': ctx.hex(),
                                 b'parents': [ctx.p1().hex()],
                                 b'branch': ctx.branch(),
                             },
                         }
                     ),
                 }
                 callconduit(ctx.repo().ui, b'differential.setdiffproperty', params)
             def createdifferentialrevision(
                 ctx,
                 revid=None,
                 parentrevphid=None,
                 oldnode=None,
                 olddiff=None,
                 actions=None,
                 comment=None,
             ):
                 """create or update a Differential Revision
                 If revid is None, create a new Differential Revision, otherwise update
                 revid. If parentrevphid is not None, set it as a dependency.
                 If oldnode is not None, check if the patch content (without commit message
                 and metadata) has changed before creating another diff.
                 If actions is not None, they will be appended to the transaction.
                 """
                 repo = ctx.repo()
                 if oldnode:
                     diffopts = mdiff.diffopts(git=True, context=32767)
                     oldctx = repo.unfiltered()[oldnode]
                     neednewdiff = getdiff(ctx, diffopts) != getdiff(oldctx, diffopts)
                 else:
                     neednewdiff = True
                 transactions = []
                 if neednewdiff:
                     diff = creatediff(ctx)
                     transactions.append({b'type': b'update', b'value': diff[b'phid']})
                     if comment:
                         transactions.append({b'type': b'comment', b'value': comment})
                 else:
                     # Even if we don't need to upload a new diff because the patch content
                     # does not change. We might still need to update its metadata so
                     # pushers could know the correct node metadata.
                     assert olddiff
                     diff = olddiff
                 writediffproperties(ctx, diff)
                 # Set the parent Revision every time, so commit re-ordering is picked-up
                 if parentrevphid:
                     transactions.append(
                         {b'type': b'parents.set', b'value': [parentrevphid]}
                     )
                 if actions:
                     transactions += actions
                 # Parse commit message and update related fields.
                 desc = ctx.description()
                 info = callconduit(
                     repo.ui, b'differential.parsecommitmessage', {b'corpus': desc}
                 )
                 for k, v in info[b'fields'].items():
                     if k in [b'title', b'summary', b'testPlan']:
                         transactions.append({b'type': k, b'value': v})
                 params = {b'transactions': transactions}
                 if revid is not None:
                     # Update an existing Differential Revision
                     params[b'objectIdentifier'] = revid
                 revision = callconduit(repo.ui, b'differential.revision.edit', params)
                 if not revision:
                     raise error.Abort(_(b'cannot create revision for %s') % ctx)
                 return revision, diff
             def userphids(repo, names):
                 """convert user names to PHIDs"""
                 names = [name.lower() for name in names]
                 query = {b'constraints': {b'usernames': names}}
                 result = callconduit(repo.ui, b'user.search', query)
                 # username not found is not an error of the API. So check if we have missed
                 # some names here.
                 data = result[b'data']
                 resolved = set(entry[b'fields'][b'username'].lower() for entry in data)
                 unresolved = set(names) - resolved
                 if unresolved:
                     raise error.Abort(
                         _(b'unknown username: %s') % b' '.join(sorted(unresolved))
                     )
                 return [entry[b'phid'] for entry in data]
             @vcrcommand(
                 b'phabsend',
                 [
                     (b'r', b'rev', [], _(b'revisions to send'), _(b'REV')),
                     (b'', b'amend', True, _(b'update commit messages')),
                     (b'', b'reviewer', [], _(b'specify reviewers')),
                     (b'', b'blocker', [], _(b'specify blocking reviewers')),
                     (
                         b'm',
                         b'comment',
                         b'',
                         _(b'add a comment to Revisions with new/updated Diffs'),
                     ),
                     (b'', b'confirm', None, _(b'ask for confirmation before sending')),
                 ],
                 _(b'REV [OPTIONS]'),
                 helpcategory=command.CATEGORY_IMPORT_EXPORT,
             )
             def phabsend(ui, repo, *revs, **opts):
                 """upload changesets to Phabricator
                 If there are multiple revisions specified, they will be send as a stack
                 with a linear dependencies relationship using the order specified by the
                 revset.
                 For the first time uploading changesets, local tags will be created to
                 maintain the association. After the first time, phabsend will check
                 obsstore and tags information so it can figure out whether to update an
                 existing Differential Revision, or create a new one.
                 If --amend is set, update commit messages so they have the
                 ``Differential Revision`` URL, remove related tags. This is similar to what
                 arcanist will do, and is more desired in author-push workflows. Otherwise,
                 use local tags to record the ``Differential Revision`` association.
                 The --confirm option lets you confirm changesets before sending them. You
                 can also add following to your configuration file to make it default
                 behaviour::
                     [phabsend]
                     confirm = true
                 phabsend will check obsstore and the above association to decide whether to
                 update an existing Differential Revision, or create a new one.
                 """
                 opts = pycompat.byteskwargs(opts)
                 revs = list(revs) + opts.get(b'rev', [])
                 revs = scmutil.revrange(repo, revs)
                 revs.sort()  # ascending order to preserve topological parent/child in phab
                 if not revs:
                     raise error.Abort(_(b'phabsend requires at least one changeset'))
                 if opts.get(b'amend'):
                     cmdutil.checkunfinished(repo)
                 # {newnode: (oldnode, olddiff, olddrev}
                 oldmap = getoldnodedrevmap(repo, [repo[r].node() for r in revs])
                 confirm = ui.configbool(b'phabsend', b'confirm')
                 confirm |= bool(opts.get(b'confirm'))
                 if confirm:
                     confirmed = _confirmbeforesend(repo, revs, oldmap)
                     if not confirmed:
                         raise error.Abort(_(b'phabsend cancelled'))
                 actions = []
                 reviewers = opts.get(b'reviewer', [])
                 blockers = opts.get(b'blocker', [])
                 phids = []
                 if reviewers:
                     phids.extend(userphids(repo, reviewers))
                 if blockers:
                     phids.extend(
                         map(lambda phid: b'blocking(%s)' % phid, userphids(repo, blockers))
                     )
                 if phids:
                     actions.append({b'type': b'reviewers.add', b'value': phids})
                 drevids = []  # [int]
                 diffmap = {}  # {newnode: diff}
                 # Send patches one by one so we know their Differential Revision PHIDs and
                 # can provide dependency relationship
                 lastrevphid = None
                 for rev in revs:
                     ui.debug(b'sending rev %d\n' % rev)
                     ctx = repo[rev]
                     # Get Differential Revision ID
                     oldnode, olddiff, revid = oldmap.get(ctx.node(), (None, None, None))
                     if oldnode != ctx.node() or opts.get(b'amend'):
                         # Create or update Differential Revision
                         revision, diff = createdifferentialrevision(
                             ctx,
                             revid,
                             lastrevphid,
                             oldnode,
                             olddiff,
                             actions,
                             opts.get(b'comment'),
                         )
                         diffmap[ctx.node()] = diff
                         newrevid = int(revision[b'object'][b'id'])
                         newrevphid = revision[b'object'][b'phid']
                         if revid:
                             action = b'updated'
                         else:
                             action = b'created'
                         # Create a local tag to note the association, if commit message
                         # does not have it already
                         m = _differentialrevisiondescre.search(ctx.description())
                         if not m or int(m.group('id')) != newrevid:
                             tagname = b'D%d' % newrevid
                             tags.tag(
                                 repo,
                                 tagname,
                                 ctx.node(),
                                 message=None,
                                 user=None,
                                 date=None,
                                 local=True,
                             )
                     else:
                         # Nothing changed. But still set "newrevphid" so the next revision
                         # could depend on this one and "newrevid" for the summary line.
                         newrevphid = querydrev(repo, b'%d' % revid)[0][b'phid']
                         newrevid = revid
                         action = b'skipped'
                     actiondesc = ui.label(
                         {
                             b'created': _(b'created'),
                             b'skipped': _(b'skipped'),
                             b'updated': _(b'updated'),
                         }[action],
                         b'phabricator.action.%s' % action,
                     )
                     drevdesc = ui.label(b'D%d' % newrevid, b'phabricator.drev')
                     nodedesc = ui.label(bytes(ctx), b'phabricator.node')
                     desc = ui.label(ctx.description().split(b'\n')[0], b'phabricator.desc')
                     ui.write(
                         _(b'%s - %s - %s: %s\n') % (drevdesc, actiondesc, nodedesc, desc)
                     )
                     drevids.append(newrevid)
                     lastrevphid = newrevphid
                 # Update commit messages and remove tags
                 if opts.get(b'amend'):
                     unfi = repo.unfiltered()
                     drevs = callconduit(ui, b'differential.query', {b'ids': drevids})
                     with repo.wlock(), repo.lock(), repo.transaction(b'phabsend'):
                         wnode = unfi[b'.'].node()
                         mapping = {}  # {oldnode: [newnode]}
                         for i, rev in enumerate(revs):
                             old = unfi[rev]
                             drevid = drevids[i]
                             drev = [d for d in drevs if int(d[b'id']) == drevid][0]
                             newdesc = getdescfromdrev(drev)
                             # Make sure commit message contain "Differential Revision"
                             if old.description() != newdesc:
                                 if old.phase() == phases.public:
                                     ui.warn(
                                         _(b"warning: not updating public commit %s\n")
                                         % scmutil.formatchangeid(old)
                                     )
                                     continue
                                 parents = [
                                     mapping.get(old.p1().node(), (old.p1(),))[0],
                                     mapping.get(old.p2().node(), (old.p2(),))[0],
                                 ]
                                 new = context.metadataonlyctx(
                                     repo,
                                     old,
                                     parents=parents,
                                     text=newdesc,
                                     user=old.user(),
                                     date=old.date(),
                                     extra=old.extra(),
                                 )
                                 newnode = new.commit()
                                 mapping[old.node()] = [newnode]
                                 # Update diff property
                                 # If it fails just warn and keep going, otherwise the DREV
                                 # associations will be lost
                                 try:
                                     writediffproperties(unfi[newnode], diffmap[old.node()])
                                 except util.urlerr.urlerror:
                                     ui.warnnoi18n(
                                         b'Failed to update metadata for D%d\n' % drevid
                                     )
                             # Remove local tags since it's no longer necessary
                             tagname = b'D%d' % drevid
                             if tagname in repo.tags():
                                 tags.tag(
                                     repo,
                                     tagname,
                                     nullid,
                                     message=None,
                                     user=None,
                                     date=None,
                                     local=True,
                                 )
                         scmutil.cleanupnodes(repo, mapping, b'phabsend', fixphase=True)
                         if wnode in mapping:
                             unfi.setparents(mapping[wnode][0])
             # Map from "hg:meta" keys to header understood by "hg import". The order is
             # consistent with "hg export" output.
             _metanamemap = util.sortdict(
                 [
                     (b'user', b'User'),
                     (b'date', b'Date'),
                     (b'branch', b'Branch'),
                     (b'node', b'Node ID'),
                     (b'parent', b'Parent '),
                 ]
             )
             def _confirmbeforesend(repo, revs, oldmap):
                 url, token = readurltoken(repo.ui)
                 ui = repo.ui
                 for rev in revs:
                     ctx = repo[rev]
                     desc = ctx.description().splitlines()[0]
                     oldnode, olddiff, drevid = oldmap.get(ctx.node(), (None, None, None))
                     if drevid:
                         drevdesc = ui.label(b'D%d' % drevid, b'phabricator.drev')
                     else:
                         drevdesc = ui.label(_(b'NEW'), b'phabricator.drev')
                     ui.write(
                         _(b'%s - %s: %s\n')
                         % (
                             drevdesc,
                             ui.label(bytes(ctx), b'phabricator.node'),
                             ui.label(desc, b'phabricator.desc'),
                         )
                     )
                 if ui.promptchoice(
                     _(b'Send the above changes to %s (yn)?$$ &Yes $$ &No') % url
                 ):
                     return False
                 return True
             _knownstatusnames = {
                 b'accepted',
                 b'needsreview',
                 b'needsrevision',
                 b'closed',
                 b'abandoned',
                 b'changesplanned',
             }
             def _getstatusname(drev):
                 """get normalized status name from a Differential Revision"""
                 return drev[b'statusName'].replace(b' ', b'').lower()
             # Small language to specify differential revisions. Support symbols: (), :X,
             # +, and -.
             _elements = {
                 # token-type: binding-strength, primary, prefix, infix, suffix
                 b'(': (12, None, (b'group', 1, b')'), None, None),
                 b':': (8, None, (b'ancestors', 8), None, None),
                 b'&': (5, None, None, (b'and_', 5), None),
                 b'+': (4, None, None, (b'add', 4), None),
                 b'-': (4, None, None, (b'sub', 4), None),
                 b')': (0, None, None, None, None),
                 b'symbol': (0, b'symbol', None, None, None),
                 b'end': (0, None, None, None, None),
             }
             def _tokenize(text):
                 view = memoryview(text)  # zero-copy slice
                 special = b'():+-& '
                 pos = 0
                 length = len(text)
                 while pos < length:
                     symbol = b''.join(
                         itertools.takewhile(
                             lambda ch: ch not in special, pycompat.iterbytestr(view[pos:])
                         )
                     )
                     if symbol:
                         yield (b'symbol', symbol, pos)
                         pos += len(symbol)
                     else:  # special char, ignore space
                         if text[pos : pos + 1] != b' ':
                             yield (text[pos : pos + 1], None, pos)
                         pos += 1
                 yield (b'end', None, pos)
             def _parse(text):
                 tree, pos = parser.parser(_elements).parse(_tokenize(text))
                 if pos != len(text):
                     raise error.ParseError(b'invalid token', pos)
                 return tree
             def _parsedrev(symbol):
                 """str -> int or None, ex. 'D45' -> 45; '12' -> 12; 'x' -> None"""
                 if symbol.startswith(b'D') and symbol[1:].isdigit():
                     return int(symbol[1:])
                 if symbol.isdigit():
                     return int(symbol)
             def _prefetchdrevs(tree):
                 """return ({single-drev-id}, {ancestor-drev-id}) to prefetch"""
                 drevs = set()
                 ancestordrevs = set()
                 op = tree[0]
                 if op == b'symbol':
                     r = _parsedrev(tree[1])
                     if r:
                         drevs.add(r)
                 elif op == b'ancestors':
                     r, a = _prefetchdrevs(tree[1])
                     drevs.update(r)
                     ancestordrevs.update(r)
                     ancestordrevs.update(a)
                 else:
                     for t in tree[1:]:
                         r, a = _prefetchdrevs(t)
                         drevs.update(r)
                         ancestordrevs.update(a)
                 return drevs, ancestordrevs
             def querydrev(repo, spec):
                 """return a list of "Differential Revision" dicts
                 spec is a string using a simple query language, see docstring in phabread
                 for details.
                 A "Differential Revision dict" looks like:
                     {
                         "id": "2",
                         "phid": "PHID-DREV-672qvysjcczopag46qty",
                         "title": "example",
                         "uri": "https://phab.example.com/D2",
                         "dateCreated": "1499181406",
                         "dateModified": "1499182103",
                         "authorPHID": "PHID-USER-tv3ohwc4v4jeu34otlye",
                         "status": "0",
                         "statusName": "Needs Review",
                         "properties": [],
                         "branch": null,
                         "summary": "",
                         "testPlan": "",
                         "lineCount": "2",
                         "activeDiffPHID": "PHID-DIFF-xoqnjkobbm6k4dk6hi72",
                         "diffs": [
                           "3",
                           "4",
                         ],
                         "commits": [],
                         "reviewers": [],
                         "ccs": [],
                         "hashes": [],
                         "auxiliary": {
                           "phabricator:projects": [],
                           "phabricator:depends-on": [
                             "PHID-DREV-gbapp366kutjebt7agcd"
                           ]
                         },
                         "repositoryPHID": "PHID-REPO-hub2hx62ieuqeheznasv",
                         "sourcePath": null
                     }
                 """
                 def fetch(params):
                     """params -> single drev or None"""
                     key = (params.get(b'ids') or params.get(b'phids') or [None])[0]
                     if key in prefetched:
                         return prefetched[key]
                     drevs = callconduit(repo.ui, b'differential.query', params)
                     # Fill prefetched with the result
                     for drev in drevs:
                         prefetched[drev[b'phid']] = drev
                         prefetched[int(drev[b'id'])] = drev
                     if key not in prefetched:
                         raise error.Abort(
                             _(b'cannot get Differential Revision %r') % params
                         )
                     return prefetched[key]
                 def getstack(topdrevids):
                     """given a top, get a stack from the bottom, [id] -> [id]"""
                     visited = set()
                     result = []
                     queue = [{b'ids': [i]} for i in topdrevids]
                     while queue:
                         params = queue.pop()
                         drev = fetch(params)
                         if drev[b'id'] in visited:
                             continue
                         visited.add(drev[b'id'])
                         result.append(int(drev[b'id']))
                         auxiliary = drev.get(b'auxiliary', {})
                         depends = auxiliary.get(b'phabricator:depends-on', [])
                         for phid in depends:
                             queue.append({b'phids': [phid]})
                     result.reverse()
                     return smartset.baseset(result)
                 # Initialize prefetch cache
                 prefetched = {}  # {id or phid: drev}
                 tree = _parse(spec)
                 drevs, ancestordrevs = _prefetchdrevs(tree)
                 # developer config: phabricator.batchsize
                 batchsize = repo.ui.configint(b'phabricator', b'batchsize')
                 # Prefetch Differential Revisions in batch
                 tofetch = set(drevs)
                 for r in ancestordrevs:
                     tofetch.update(range(max(1, r - batchsize), r + 1))
                 if drevs:
                     fetch({b'ids': list(tofetch)})
                 validids = sorted(set(getstack(list(ancestordrevs))) | set(drevs))
                 # Walk through the tree, return smartsets
                 def walk(tree):
                     op = tree[0]
                     if op == b'symbol':
                         drev = _parsedrev(tree[1])
                         if drev:
                             return smartset.baseset([drev])
                         elif tree[1] in _knownstatusnames:
                             drevs = [
                                 r
                                 for r in validids
                                 if _getstatusname(prefetched[r]) == tree[1]
                             ]
                             return smartset.baseset(drevs)
                         else:
                             raise error.Abort(_(b'unknown symbol: %s') % tree[1])
                     elif op in {b'and_', b'add', b'sub'}:
                         assert len(tree) == 3
                         return getattr(operator, op)(walk(tree[1]), walk(tree[2]))
                     elif op == b'group':
                         return walk(tree[1])
                     elif op == b'ancestors':
                         return getstack(walk(tree[1]))
                     else:
                         raise error.ProgrammingError(b'illegal tree: %r' % tree)
                 return [prefetched[r] for r in walk(tree)]
             def getdescfromdrev(drev):
                 """get description (commit message) from "Differential Revision"
                 This is similar to differential.getcommitmessage API. But we only care
                 about limited fields: title, summary, test plan, and URL.
                 """
                 title = drev[b'title']
                 summary = drev[b'summary'].rstrip()
                 testplan = drev[b'testPlan'].rstrip()
                 if testplan:
                     testplan = b'Test Plan:\n%s' % testplan
                 uri = b'Differential Revision: %s' % drev[b'uri']
                 return b'\n\n'.join(filter(None, [title, summary, testplan, uri]))
             def getdiffmeta(diff):
                 """get commit metadata (date, node, user, p1) from a diff object
                 The metadata could be "hg:meta", sent by phabsend, like:
                     "properties": {
                       "hg:meta": {
                         "date": "1499571514 25200",
                         "node": "98c08acae292b2faf60a279b4189beb6cff1414d",
                         "user": "Foo Bar <foo@example.com>",
                         "parent": "6d0abad76b30e4724a37ab8721d630394070fe16"
                       }
                     }
                 Or converted from "local:commits", sent by "arc", like:
                     "properties": {
                       "local:commits": {
                         "98c08acae292b2faf60a279b4189beb6cff1414d": {
                           "author": "Foo Bar",
                           "time": 1499546314,
                           "branch": "default",
                           "tag": "",
                           "commit": "98c08acae292b2faf60a279b4189beb6cff1414d",
                           "rev": "98c08acae292b2faf60a279b4189beb6cff1414d",
                           "local": "1000",
                           "parents": ["6d0abad76b30e4724a37ab8721d630394070fe16"],
                           "summary": "...",
                           "message": "...",
                           "authorEmail": "foo@example.com"
                         }
                       }
                     }
                 Note: metadata extracted from "local:commits" will lose time zone
                 information.
                 """
                 props = diff.get(b'properties') or {}
                 meta = props.get(b'hg:meta')
                 if not meta:
                     if props.get(b'local:commits'):
                         commit = sorted(props[b'local:commits'].values())[0]
                         meta = {}
                         if b'author' in commit and b'authorEmail' in commit:
                             meta[b'user'] = b'%s <%s>' % (
                                 commit[b'author'],
                                 commit[b'authorEmail'],
                             )
                         if b'time' in commit:
                             meta[b'date'] = b'%d 0' % int(commit[b'time'])
                         if b'branch' in commit:
                             meta[b'branch'] = commit[b'branch']
                         node = commit.get(b'commit', commit.get(b'rev'))
                         if node:
                             meta[b'node'] = node
                         if len(commit.get(b'parents', ())) >= 1:
                             meta[b'parent'] = commit[b'parents'][0]
                     else:
                         meta = {}
                 if b'date' not in meta and b'dateCreated' in diff:
                     meta[b'date'] = b'%s 0' % diff[b'dateCreated']
                 if b'branch' not in meta and diff.get(b'branch'):
                     meta[b'branch'] = diff[b'branch']
                 if b'parent' not in meta and diff.get(b'sourceControlBaseRevision'):
                     meta[b'parent'] = diff[b'sourceControlBaseRevision']
                 return meta
             def readpatch(repo, drevs, write):
                 """generate plain-text patch readable by 'hg import'
                 write is usually ui.write. drevs is what "querydrev" returns, results of
                 "differential.query".
                 """
                 # Prefetch hg:meta property for all diffs
                 diffids = sorted(set(max(int(v) for v in drev[b'diffs']) for drev in drevs))
                 diffs = callconduit(repo.ui, b'differential.querydiffs', {b'ids': diffids})
                 # Generate patch for each drev
                 for drev in drevs:
                     repo.ui.note(_(b'reading D%s\n') % drev[b'id'])
                     diffid = max(int(v) for v in drev[b'diffs'])
                     body = callconduit(
                         repo.ui, b'differential.getrawdiff', {b'diffID': diffid}
                     )
                     desc = getdescfromdrev(drev)
                     header = b'# HG changeset patch\n'
                     # Try to preserve metadata from hg:meta property. Write hg patch
                     # headers that can be read by the "import" command. See patchheadermap
                     # and extract in mercurial/patch.py for supported headers.
                     meta = getdiffmeta(diffs[b'%d' % diffid])
                     for k in _metanamemap.keys():
                         if k in meta:
                             header += b'# %s %s\n' % (_metanamemap[k], meta[k])
                     content = b'%s%s\n%s' % (header, desc, body)
                     write(content)
             @vcrcommand(
                 b'phabread',
                 [(b'', b'stack', False, _(b'read dependencies'))],
                 _(b'DREVSPEC [OPTIONS]'),
                 helpcategory=command.CATEGORY_IMPORT_EXPORT,
             )
             def phabread(ui, repo, spec, **opts):
                 """print patches from Phabricator suitable for importing
                 DREVSPEC could be a Differential Revision identity, like ``D123``, or just
                 the number ``123``. It could also have common operators like ``+``, ``-``,
                 ``&``, ``(``, ``)`` for complex queries. Prefix ``:`` could be used to
                 select a stack.
                 ``abandoned``, ``accepted``, ``closed``, ``needsreview``, ``needsrevision``
                 could be used to filter patches by status. For performance reason, they
                 only represent a subset of non-status selections and cannot be used alone.
                 For example, ``:D6+8-(2+D4)`` selects a stack up to D6, plus D8 and exclude
                 D2 and D4. ``:D9 & needsreview`` selects "Needs Review" revisions in a
                 stack up to D9.
                 If --stack is given, follow dependencies information and read all patches.
                 It is equivalent to the ``:`` operator.
                 """
                 opts = pycompat.byteskwargs(opts)
                 if opts.get(b'stack'):
                     spec = b':(%s)' % spec
                 drevs = querydrev(repo, spec)
                 readpatch(repo, drevs, ui.write)
             @vcrcommand(
                 b'phabupdate',
                 [
                     (b'', b'accept', False, _(b'accept revisions')),
                     (b'', b'reject', False, _(b'reject revisions')),
                     (b'', b'abandon', False, _(b'abandon revisions')),
                     (b'', b'reclaim', False, _(b'reclaim revisions')),
                     (b'm', b'comment', b'', _(b'comment on the last revision')),
                 ],
                 _(b'DREVSPEC [OPTIONS]'),
                 helpcategory=command.CATEGORY_IMPORT_EXPORT,
             )
             def phabupdate(ui, repo, spec, **opts):
                 """update Differential Revision in batch
                 DREVSPEC selects revisions. See :hg:`help phabread` for its usage.
                 """
                 opts = pycompat.byteskwargs(opts)
                 flags = [n for n in b'accept reject abandon reclaim'.split() if opts.get(n)]
                 if len(flags) > 1:
                     raise error.Abort(_(b'%s cannot be used together') % b', '.join(flags))
                 actions = []
                 for f in flags:
                     actions.append({b'type': f, b'value': True})
                 drevs = querydrev(repo, spec)
                 for i, drev in enumerate(drevs):
                     if i + 1 == len(drevs) and opts.get(b'comment'):
                         actions.append({b'type': b'comment', b'value': opts[b'comment']})
                     if actions:
                         params = {
                             b'objectIdentifier': drev[b'phid'],
                             b'transactions': actions,
                         }
                         callconduit(ui, b'differential.revision.edit', params)
             @eh.templatekeyword(b'phabreview', requires={b'ctx'})
             def template_review(context, mapping):
                 """:phabreview: Object describing the review for this changeset.
                 Has attributes `url` and `id`.
                 """
                 ctx = context.resource(mapping, b'ctx')
                 m = _differentialrevisiondescre.search(ctx.description())
                 if m:
                     return templateutil.hybriddict(
                         {b'url': m.group('url'), b'id': b"D%s" % m.group('id'),}
                     )
                 else:
                     tags = ctx.repo().nodetags(ctx.node())
                     for t in tags:
                         if _differentialrevisiontagre.match(t):
                             url = ctx.repo().ui.config(b'phabricator', b'url')
                             if not url.endswith(b'/'):
                                 url += b'/'
                             url += t
                             return templateutil.hybriddict({b'url': url, b'id': t,})
                 return None
             @eh.templatekeyword(b'phabstatus', requires={b'ctx', b'repo', b'ui'})
             def template_status(context, mapping):
                 """:phabstatus: String. Status of Phabricator differential.
                 """
                 ctx = context.resource(mapping, b'ctx')
                 repo = context.resource(mapping, b'repo')
                 ui = context.resource(mapping, b'ui')
                 rev = ctx.rev()
                 try:
                     drevid = getdrevmap(repo, [rev])[rev]
                 except KeyError:
                     return None
                 drevs = callconduit(ui, b'differential.query', {b'ids': [drevid]})
                 for drev in drevs:
                     if int(drev[b'id']) == drevid:
                         return templateutil.hybriddict(
                             {b'url': drev[b'uri'], b'status': drev[b'statusName'],}
                         )
                 return None
             @show.showview(b'phabstatus', csettopic=b'work')
             def phabstatusshowview(ui, repo, displayer):
                 """Phabricator differiential status"""
                 revs = repo.revs('sort(_underway(), topo)')
                 drevmap = getdrevmap(repo, revs)
                 unknownrevs, drevids, revsbydrevid = [], set([]), {}
                 for rev, drevid in pycompat.iteritems(drevmap):
                     if drevid is not None:
                         drevids.add(drevid)
                         revsbydrevid.setdefault(drevid, set([])).add(rev)
                     else:
                         unknownrevs.append(rev)
                 drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)})
                 drevsbyrev = {}
                 for drev in drevs:
                     for rev in revsbydrevid[int(drev[b'id'])]:
                         drevsbyrev[rev] = drev
                 def phabstatus(ctx):
                     drev = drevsbyrev[ctx.rev()]
                     status = ui.label(
                         b'%(statusName)s' % drev,
                         b'phabricator.status.%s' % _getstatusname(drev),
                     )
                     ui.write(b"\n%s %s\n" % (drev[b'uri'], status))
                 revs -= smartset.baseset(unknownrevs)
                 revdag = graphmod.dagwalker(repo, revs)
                 ui.setconfig(b'experimental', b'graphshorten', True)
                 displayer._exthook = phabstatus
                 nodelen = show.longestshortest(repo, revs)
                 logcmdutil.displaygraph(
                     ui,
                     repo,
                     revdag,
                     displayer,
                     graphmod.asciiedges,
                     props={b'nodelen': nodelen},
                 )

tests/test-phabricator.t

0 +17 0

             #require vcr
               $ cat >> $HGRCPATH <<EOF
               > [extensions]
               > phabricator =
               > EOF
               $ hg init repo
               $ cd repo
               $ cat >> .hg/hgrc <<EOF
               > [phabricator]
               > url = https://phab.mercurial-scm.org/
               > callsign = HG
               >
               > [auth]
               > hgphab.schemes = https
               > hgphab.prefix = phab.mercurial-scm.org
               > # When working on the extension and making phabricator interaction
               > # changes, edit this to be a real phabricator token. When done, edit
               > # it back. The VCR transcripts will be auto-sanitised to replace your real
               > # token with this value.
               > hgphab.phabtoken = cli-hahayouwish
               > EOF
               $ VCR="$TESTDIR/phabricator"
             Error is handled reasonably. We override the phabtoken here so that
             when you're developing changes to phabricator.py you can edit the
             above config and have a real token in the test but not have to edit
             this test.
               $ hg phabread --config auth.hgphab.phabtoken=cli-notavalidtoken \
               >  --test-vcr "$VCR/phabread-conduit-error.json" D4480 | head
               abort: Conduit Error (ERR-INVALID-AUTH): API token "cli-notavalidtoken" has the wrong length. API tokens should be 32 characters long.
             Basic phabread:
               $ hg phabread --test-vcr "$VCR/phabread-4480.json" D4480 | head
               # HG changeset patch
               # Date 1536771503 0
               # Parent  a5de21c9e3703f8e8eb064bd7d893ff2f703c66a
               exchangev2: start to implement pull with wire protocol v2
               Wire protocol version 2 will take a substantially different
               approach to exchange than version 1 (at least as far as pulling
               is concerned).
               This commit establishes a new exchangev2 module for holding
             phabupdate with an accept:
               $ hg phabupdate --accept D4564 \
               > -m 'I think I like where this is headed. Will read rest of series later.'\
               >  --test-vcr "$VCR/accept-4564.json"
               abort: Conduit Error (ERR-CONDUIT-CORE): Validation errors:
                 - You can not accept this revision because it has already been closed. Only open revisions can be accepted.
               [255]
               $ hg phabupdate --accept D7913 -m 'LGTM' --test-vcr "$VCR/accept-7913.json"
             Create a differential diff:
               $ HGENCODING=utf-8; export HGENCODING
               $ echo alpha > alpha
               $ hg ci --addremove -m 'create alpha for phabricator test €'
               adding alpha
               $ hg phabsend -r . --test-vcr "$VCR/phabsend-create-alpha.json"
               D7915 - created - d386117f30e6: create alpha for phabricator test \xe2\x82\xac (esc)
               saved backup bundle to $TESTTMP/repo/.hg/strip-backup/d386117f30e6-24ffe649-phabsend.hg
               $ echo more >> alpha
               $ HGEDITOR=true hg ci --amend
               saved backup bundle to $TESTTMP/repo/.hg/strip-backup/347bf67801e5-3bf313e4-amend.hg
               $ echo beta > beta
               $ hg ci --addremove -m 'create beta for phabricator test'
               adding beta
               $ hg phabsend -r ".^::" --test-vcr "$VCR/phabsend-update-alpha-create-beta.json"
               D7915 - updated - c44b38f24a45: create alpha for phabricator test \xe2\x82\xac (esc)
               D7916 - created - 9e6901f21d5b: create beta for phabricator test
               saved backup bundle to $TESTTMP/repo/.hg/strip-backup/9e6901f21d5b-1fcd4f0e-phabsend.hg
               $ unset HGENCODING
             The amend won't explode after posting a public commit.  The local tag is left
             behind to identify it.
               $ echo 'public change' > beta
               $ hg ci -m 'create public change for phabricator testing'
               $ hg phase --public .
               $ echo 'draft change' > alpha
               $ hg ci -m 'create draft change for phabricator testing'
               $ hg phabsend --amend -r '.^::' --test-vcr "$VCR/phabsend-create-public.json"
               D7917 - created - 7b4185ab5d16: create public change for phabricator testing
               D7918 - created - 251c1c333fc6: create draft change for phabricator testing
               warning: not updating public commit 2:7b4185ab5d16
               saved backup bundle to $TESTTMP/repo/.hg/strip-backup/251c1c333fc6-41cb7c3b-phabsend.hg
               $ hg tags -v
               tip                                3:3244dc4a3334
               D7917                              2:7b4185ab5d16 local
               $ hg debugcallconduit user.search --test-vcr "$VCR/phab-conduit.json" <<EOF
               > {
               >     "constraints": {
               >         "isBot": true
               >     }
               > }
               > EOF
               {
                 "cursor": {
                   "after": null,
                   "before": null,
                   "limit": 100,
                   "order": null
                 },
                 "data": [],
                 "maps": {},
                 "query": {
                   "queryKey": null
                 }
               }
             Template keywords
               $ hg log -T'{rev} {phabreview|json}\n'
 {"id": "D7918", "url": "https://phab.mercurial-scm.org/D7918"}
 {"id": "D7917", "url": "https://phab.mercurial-scm.org/D7917"}
 {"id": "D7916", "url": "https://phab.mercurial-scm.org/D7916"}
 {"id": "D7915", "url": "https://phab.mercurial-scm.org/D7915"}
               $ hg log -T'{rev} {if(phabreview, "{phabreview.url} {phabreview.id}")}\n'
 https://phab.mercurial-scm.org/D7918 D7918
 https://phab.mercurial-scm.org/D7917 D7917
 https://phab.mercurial-scm.org/D7916 D7916
 https://phab.mercurial-scm.org/D7915 D7915
             Commenting when phabsending:
               $ echo comment > comment
               $ hg ci --addremove -m "create comment for phabricator test"
               adding comment
               $ hg phabsend -r . -m "For default branch" --test-vcr "$VCR/phabsend-comment-created.json"
               D7919 - created - d5dddca9023d: create comment for phabricator test
               saved backup bundle to $TESTTMP/repo/.hg/strip-backup/d5dddca9023d-adf673ba-phabsend.hg
               $ echo comment2 >> comment
               $ hg ci --amend
               saved backup bundle to $TESTTMP/repo/.hg/strip-backup/f7db812bbe1d-8fcded77-amend.hg
               $ hg phabsend -r . -m "Address review comments" --test-vcr "$VCR/phabsend-comment-updated.json"
               D7919 - updated - 1849d7828727: create comment for phabricator test
             Phabsending a skipped commit:
               $ hg phabsend --no-amend -r . --test-vcr "$VCR/phabsend-skipped.json"
               D7919 - skipped - 1849d7828727: create comment for phabricator test
+            Phabesending a new binary, a modified binary, and a removed binary
+              >>> open('bin', 'wb').write(b'\0a') and None
+              $ hg ci -Am 'add binary'
+              adding bin
+              >>> open('bin', 'wb').write(b'\0b') and None
+              $ hg ci -m 'modify binary'
+              $ hg rm bin
+              $ hg ci -m 'remove binary'
+              $ hg phabsend -r .~2:: --test-vcr "$VCR/phabsend-binary.json"
+              uploading bin@aa24a81f55de
+              D8007 - created - aa24a81f55de: add binary
+              uploading bin@d8d62a881b54
+              D8008 - created - d8d62a881b54: modify binary
+              D8009 - created - af55645b2e29: remove binary
+              saved backup bundle to $TESTTMP/repo/.hg/strip-backup/aa24a81f55de-a3a0cf24-phabsend.hg
             Phabreading a DREV with a local:commits time as a string:
               $ hg phabread --test-vcr "$VCR/phabread-str-time.json" D1285
               # HG changeset patch
               # User Pulkit Goyal <7895pulkit@gmail.com>
               # Date 1509404054 -19800
               # Node ID 44fc1c1f1774a76423b9c732af6938435099bcc5
               # Parent  8feef8ef8389a3b544e0a74624f1efc3a8d85d35
               repoview: add a new attribute _visibilityexceptions and related API
               Currently we don't have a defined way in core to make some hidden revisions
               visible in filtered repo. Extensions to achieve the purpose of unhiding some
               hidden commits, wrap repoview.pinnedrevs() function.
               To make the above task simple and have well defined API, this patch adds a new
               attribute '_visibilityexceptions' to repoview class which will contains
               the hidden revs which should be exception.
               This will allow to set different exceptions for different repoview objects
               backed by the same unfiltered repo.
               This patch also adds API to add revs to the attribute set and get them.
               Thanks to Jun for suggesting the use of repoview class instead of localrepo.
               Differential Revision: https://phab.mercurial-scm.org/D1285
               diff --git a/mercurial/repoview.py b/mercurial/repoview.py
               --- a/mercurial/repoview.py
               +++ b/mercurial/repoview.py
               @@ * @@ (glob)
                    subclasses of `localrepo`. Eg: `bundlerepo` or `statichttprepo`.
                    """
               +    # hidden revs which should be visible
               +    _visibilityexceptions = set()
               +
                    def __init__(self, repo, filtername):
                        object.__setattr__(self, r'_unfilteredrepo', repo)
                        object.__setattr__(self, r'filtername', filtername)
               @@ -231,6 +234,14 @@
                            return self
                        return self.unfiltered().filtered(name)
               +    def addvisibilityexceptions(self, revs):
               +        """adds hidden revs which should be visible to set of exceptions"""
               +        self._visibilityexceptions.update(revs)
               +
               +    def getvisibilityexceptions(self):
               +        """returns the set of hidden revs which should be visible"""
               +        return self._visibilityexceptions
               +
                    # everything access are forwarded to the proxied repo
                    def __getattr__(self, attr):
                        return getattr(self._unfilteredrepo, attr)
               diff --git a/mercurial/localrepo.py b/mercurial/localrepo.py
               --- a/mercurial/localrepo.py
               +++ b/mercurial/localrepo.py
               @@ -570,6 +570,14 @@
                    def close(self):
                        self._writecaches()
               +    def addvisibilityexceptions(self, exceptions):
               +        # should be called on a filtered repository
               +        pass
               +
               +    def getvisibilityexceptions(self):
               +        # should be called on a filtered repository
               +        return set()
               +
                    def _loadextensions(self):
                        extensions.loadall(self.ui)
             A bad .arcconfig doesn't error out
               $ echo 'garbage' > .arcconfig
               $ hg config phabricator --debug
               invalid JSON in $TESTTMP/repo/.arcconfig
               read config from: */.hgrc (glob)
               $TESTTMP/repo/.hg/hgrc:*: phabricator.url=https://phab.mercurial-scm.org/ (glob)
               $TESTTMP/repo/.hg/hgrc:*: phabricator.callsign=HG (glob)
             The .arcconfig content overrides global config
               $ cat >> $HGRCPATH << EOF
               > [phabricator]
               > url = global
               > callsign = global
               > EOF
               $ cp $TESTDIR/../.arcconfig .
               $ mv .hg/hgrc .hg/hgrc.bak
               $ hg config phabricator --debug
               read config from: */.hgrc (glob)
               $TESTTMP/repo/.arcconfig: phabricator.callsign=HG
               $TESTTMP/repo/.arcconfig: phabricator.url=https://phab.mercurial-scm.org/
             But it doesn't override local config
               $ cat >> .hg/hgrc << EOF
               > [phabricator]
               > url = local
               > callsign = local
               > EOF
               $ hg config phabricator --debug
               read config from: */.hgrc (glob)
               $TESTTMP/repo/.hg/hgrc:*: phabricator.url=local (glob)
               $TESTTMP/repo/.hg/hgrc:*: phabricator.callsign=local (glob)
               $ mv .hg/hgrc.bak .hg/hgrc
               $ cd ..

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages