upstream/mercurial-mirror Commit - r37489:51d5e1ff

1

# patch.py - patch file parsing routines

1

# patch.py - patch file parsing routines

2

#

2

#

3

4

5

#

5

#

6

# This software may be used and distributed according to the terms of the

6

# This software may be used and distributed according to the terms of the

7

# GNU General Public License version 2 or any later version.

7

# GNU General Public License version 2 or any later version.

8

9

from __future__ import absolute_import, print_function

9

from __future__ import absolute_import, print_function

10

11

import collections

11

import collections

12

import copy

12

import copy

13

import difflib

13

import difflib

14

import email

14

import email

15

import errno

15

import errno

16

import hashlib

16

import hashlib

17

import os

17

import os

18

import posixpath

18

import posixpath

19

import re

19

import re

20

import shutil

20

import shutil

21

import tempfile

21

import tempfile

22

import zlib

22

import zlib

23

24

from .i18n import _

24

from .i18n import _

25

from .node import (

25

from .node import (

26

hex,

26

hex,

27

short,

27

short,

28

)

28

)

29

from . import (

29

from . import (

30

copies,

30

copies,

31

encoding,

31

encoding,

32

error,

32

error,

33

mail,

33

mail,

34

mdiff,

34

mdiff,

35

pathutil,

35

pathutil,

36

policy,

36

policy,

37

pycompat,

37

pycompat,

38

scmutil,

38

scmutil,

39

similar,

39

similar,

40

util,

40

util,

41

vfs as vfsmod,

41

vfs as vfsmod,

42

)

42

)

43

from .utils import (

43

from .utils import (

44

dateutil,

44

dateutil,

45

procutil,

45

procutil,

46

stringutil,

46

stringutil,

47

)

47

)

48

49

diffhelpers = policy.importmod(r'diffhelpers')

49

diffhelpers = policy.importmod(r'diffhelpers')

50

stringio = util.stringio

50

stringio = util.stringio

51

52

gitre = re.compile(br'diff --git a/(.*) b/(.*)')

52

gitre = re.compile(br'diff --git a/(.*) b/(.*)')

53

tabsplitter = re.compile(br'(\t+|[^\t]+)')

53

tabsplitter = re.compile(br'(\t+|[^\t]+)')

54

_nonwordre = re.compile(br'([^a-zA-Z0-9_\x80-\xff])')

54

_nonwordre = re.compile(br'([^a-zA-Z0-9_\x80-\xff])')

55

56

PatchError = error.PatchError

56

PatchError = error.PatchError

57

58

# public functions

58

# public functions

59

60

def split(stream):

60

def split(stream):

61

'''return an iterator of individual patches from a stream'''

61

'''return an iterator of individual patches from a stream'''

62

def isheader(line, inheader):

62

def isheader(line, inheader):

63

if inheader and line[0] in (' ', '\t'):

63

if inheader and line.startswith((' ', '\t')):

64

# continuation

64

# continuation

65

return True

65

return True

66

if line[0] in (' ', '-', '+'):

66

if line.startswith((' ', '-', '+')):

67

# diff line - don't check for header pattern in there

67

# diff line - don't check for header pattern in there

68

return False

68

return False

69

l = line.split(': ', 1)

69

l = line.split(': ', 1)

70

return len(l) == 2 and ' ' not in l[0]

70

return len(l) == 2 and ' ' not in l[0]

71

72

def chunk(lines):

72

def chunk(lines):

73

return stringio(''.join(lines))

73

return stringio(''.join(lines))

74

75

def hgsplit(stream, cur):

75

def hgsplit(stream, cur):

76

inheader = True

76

inheader = True

77

78

for line in stream:

78

for line in stream:

79

if not line.strip():

79

if not line.strip():

80

inheader = False

80

inheader = False

81

if not inheader and line.startswith('# HG changeset patch'):

81

if not inheader and line.startswith('# HG changeset patch'):

82

yield chunk(cur)

82

yield chunk(cur)

83

cur = []

83

cur = []

84

inheader = True

84

inheader = True

85

86

cur.append(line)

86

cur.append(line)

87

88

if cur:

88

if cur:

89

yield chunk(cur)

89

yield chunk(cur)

90

91

def mboxsplit(stream, cur):

91

def mboxsplit(stream, cur):

92

for line in stream:

92

for line in stream:

93

if line.startswith('From '):

93

if line.startswith('From '):

94

for c in split(chunk(cur[1:])):

94

for c in split(chunk(cur[1:])):

95

yield c

95

yield c

96

cur = []

96

cur = []

97

98

cur.append(line)

98

cur.append(line)

99

100

if cur:

100

if cur:

101

for c in split(chunk(cur[1:])):

101

for c in split(chunk(cur[1:])):

102

yield c

102

yield c

103

104

def mimesplit(stream, cur):

104

def mimesplit(stream, cur):

105

def msgfp(m):

105

def msgfp(m):

106

fp = stringio()

106

fp = stringio()

107

g = email.Generator.Generator(fp, mangle_from_=False)

107

g = email.Generator.Generator(fp, mangle_from_=False)

108

g.flatten(m)

108

g.flatten(m)

109

fp.seek(0)

109

fp.seek(0)

110

return fp

110

return fp

111

112

for line in stream:

112

for line in stream:

113

cur.append(line)

113

cur.append(line)

114

c = chunk(cur)

114

c = chunk(cur)

115

116

m = pycompat.emailparser().parse(c)

116

m = pycompat.emailparser().parse(c)

117

if not m.is_multipart():

117

if not m.is_multipart():

118

yield msgfp(m)

118

yield msgfp(m)

119

else:

119

else:

120

ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')

120

ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')

121

for part in m.walk():

121

for part in m.walk():

122

ct = part.get_content_type()

122

ct = part.get_content_type()

123

if ct not in ok_types:

123

if ct not in ok_types:

124

continue

124

continue

125

yield msgfp(part)

125

yield msgfp(part)

126

127

def headersplit(stream, cur):

127

def headersplit(stream, cur):

128

inheader = False

128

inheader = False

129

130

for line in stream:

130

for line in stream:

131

if not inheader and isheader(line, inheader):

131

if not inheader and isheader(line, inheader):

132

yield chunk(cur)

132

yield chunk(cur)

133

cur = []

133

cur = []

134

inheader = True

134

inheader = True

135

if inheader and not isheader(line, inheader):

135

if inheader and not isheader(line, inheader):

136

inheader = False

136

inheader = False

137

138

cur.append(line)

138

cur.append(line)

139

140

if cur:

140

if cur:

141

yield chunk(cur)

141

yield chunk(cur)

142

143

def remainder(cur):

143

def remainder(cur):

144

yield chunk(cur)

144

yield chunk(cur)

145

146

class fiter(object):

146

class fiter(object):

147

def __init__(self, fp):

147

def __init__(self, fp):

148

self.fp = fp

148

self.fp = fp

149

150

def __iter__(self):

150

def __iter__(self):

151

return self

151

return self

152

153

def next(self):

153

def next(self):

154

l = self.fp.readline()

154

l = self.fp.readline()

155

if not l:

155

if not l:

156

raise StopIteration

156

raise StopIteration

157

return l

157

return l

158

159

__next__ = next

159

__next__ = next

160

161

inheader = False

161

inheader = False

162

cur = []

162

cur = []

163

164

mimeheaders = ['content-type']

164

mimeheaders = ['content-type']

165

166

if not util.safehasattr(stream, 'next'):

166

if not util.safehasattr(stream, 'next'):

167

# http responses, for example, have readline but not next

167

# http responses, for example, have readline but not next

168

stream = fiter(stream)

168

stream = fiter(stream)

169

170

for line in stream:

170

for line in stream:

171

cur.append(line)

171

cur.append(line)

172

if line.startswith('# HG changeset patch'):

172

if line.startswith('# HG changeset patch'):

173

return hgsplit(stream, cur)

173

return hgsplit(stream, cur)

174

elif line.startswith('From '):

174

elif line.startswith('From '):

175

return mboxsplit(stream, cur)

175

return mboxsplit(stream, cur)

176

elif isheader(line, inheader):

176

elif isheader(line, inheader):

177

inheader = True

177

inheader = True

178

if line.split(':', 1)[0].lower() in mimeheaders:

178

if line.split(':', 1)[0].lower() in mimeheaders:

179

# let email parser handle this

179

# let email parser handle this

180

return mimesplit(stream, cur)

180

return mimesplit(stream, cur)

181

elif line.startswith('--- ') and inheader:

181

elif line.startswith('--- ') and inheader:

182

# No evil headers seen by diff start, split by hand

182

# No evil headers seen by diff start, split by hand

183

return headersplit(stream, cur)

183

return headersplit(stream, cur)

184

# Not enough info, keep reading

184

# Not enough info, keep reading

185

186

# if we are here, we have a very plain patch

186

# if we are here, we have a very plain patch

187

return remainder(cur)

187

return remainder(cur)

188

189

## Some facility for extensible patch parsing:

189

## Some facility for extensible patch parsing:

190

# list of pairs ("header to match", "data key")

190

# list of pairs ("header to match", "data key")

191

patchheadermap = [('Date', 'date'),

191

patchheadermap = [('Date', 'date'),

192

('Branch', 'branch'),

192

('Branch', 'branch'),

193

('Node ID', 'nodeid'),

193

('Node ID', 'nodeid'),

194

]

194

]

195

196

def extract(ui, fileobj):

196

def extract(ui, fileobj):

197

'''extract patch from data read from fileobj.

197

'''extract patch from data read from fileobj.

198

199

patch can be a normal patch or contained in an email message.

199

patch can be a normal patch or contained in an email message.

200

201

return a dictionary. Standard keys are:

201

return a dictionary. Standard keys are:

202

- filename,

202

- filename,

203

- message,

203

- message,

204

- user,

204

- user,

205

- date,

205

- date,

206

- branch,

206

- branch,

207

- node,

207

- node,

208

- p1,

208

- p1,

209

- p2.

209

- p2.

210

Any item can be missing from the dictionary. If filename is missing,

210

Any item can be missing from the dictionary. If filename is missing,

211

fileobj did not contain a patch. Caller must unlink filename when done.'''

211

fileobj did not contain a patch. Caller must unlink filename when done.'''

212

213

# attempt to detect the start of a patch

213

# attempt to detect the start of a patch

214

# (this heuristic is borrowed from quilt)

214

# (this heuristic is borrowed from quilt)

215

diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'

215

diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'

216

br'retrieving revision [0-9]+(\.[0-9]+)*$|'

216

br'retrieving revision [0-9]+(\.[0-9]+)*$|'

217

br'---[ \t].*?^\+\+\+[ \t]|'

217

br'---[ \t].*?^\+\+\+[ \t]|'

218

br'\*\*\*[ \t].*?^---[ \t])',

218

br'\*\*\*[ \t].*?^---[ \t])',

219

re.MULTILINE | re.DOTALL)

219

re.MULTILINE | re.DOTALL)

220

221

data = {}

221

data = {}

222

fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')

222

fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')

223

tmpfp = os.fdopen(fd, r'wb')

223

tmpfp = os.fdopen(fd, r'wb')

224

try:

224

try:

225

msg = pycompat.emailparser().parse(fileobj)

225

msg = pycompat.emailparser().parse(fileobj)

226

227

subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject'])

227

subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject'])

228

data['user'] = msg[r'From'] and mail.headdecode(msg[r'From'])

228

data['user'] = msg[r'From'] and mail.headdecode(msg[r'From'])

229

if not subject and not data['user']:

229

if not subject and not data['user']:

230

# Not an email, restore parsed headers if any

230

# Not an email, restore parsed headers if any

231

subject = '\n'.join(': '.join(map(encoding.strtolocal, h))

231

subject = '\n'.join(': '.join(map(encoding.strtolocal, h))

232

for h in msg.items()) + '\n'

232

for h in msg.items()) + '\n'

233

234

# should try to parse msg['Date']

234

# should try to parse msg['Date']

235

parents = []

235

parents = []

236

237

if subject:

237

if subject:

238

if subject.startswith('[PATCH'):

238

if subject.startswith('[PATCH'):

239

pend = subject.find(']')

239

pend = subject.find(']')

240

if pend >= 0:

240

if pend >= 0:

241

subject = subject[pend + 1:].lstrip()

241

subject = subject[pend + 1:].lstrip()

242

subject = re.sub(br'\n[ \t]+', ' ', subject)

242

subject = re.sub(br'\n[ \t]+', ' ', subject)

243

ui.debug('Subject: %s\n' % subject)

243

ui.debug('Subject: %s\n' % subject)

244

if data['user']:

244

if data['user']:

245

ui.debug('From: %s\n' % data['user'])

245

ui.debug('From: %s\n' % data['user'])

246

diffs_seen = 0

246

diffs_seen = 0

247

ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')

247

ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')

248

message = ''

248

message = ''

249

for part in msg.walk():

249

for part in msg.walk():

250

content_type = pycompat.bytestr(part.get_content_type())

250

content_type = pycompat.bytestr(part.get_content_type())

251

ui.debug('Content-Type: %s\n' % content_type)

251

ui.debug('Content-Type: %s\n' % content_type)

252

if content_type not in ok_types:

252

if content_type not in ok_types:

253

continue

253

continue

254

payload = part.get_payload(decode=True)

254

payload = part.get_payload(decode=True)

255

m = diffre.search(payload)

255

m = diffre.search(payload)

256

if m:

256

if m:

257

hgpatch = False

257

hgpatch = False

258

hgpatchheader = False

258

hgpatchheader = False

259

ignoretext = False

259

ignoretext = False

260

261

ui.debug('found patch at byte %d\n' % m.start(0))

261

ui.debug('found patch at byte %d\n' % m.start(0))

262

diffs_seen += 1

262

diffs_seen += 1

263

cfp = stringio()

263

cfp = stringio()

264

for line in payload[:m.start(0)].splitlines():

264

for line in payload[:m.start(0)].splitlines():

265

if line.startswith('# HG changeset patch') and not hgpatch:

265

if line.startswith('# HG changeset patch') and not hgpatch:

266

ui.debug('patch generated by hg export\n')

266

ui.debug('patch generated by hg export\n')

267

hgpatch = True

267

hgpatch = True

268

hgpatchheader = True

268

hgpatchheader = True

269

# drop earlier commit message content

269

# drop earlier commit message content

270

cfp.seek(0)

270

cfp.seek(0)

271

cfp.truncate()

271

cfp.truncate()

272

subject = None

272

subject = None

273

elif hgpatchheader:

273

elif hgpatchheader:

274

if line.startswith('# User '):

274

if line.startswith('# User '):

275

data['user'] = line[7:]

275

data['user'] = line[7:]

276

ui.debug('From: %s\n' % data['user'])

276

ui.debug('From: %s\n' % data['user'])

277

elif line.startswith("# Parent "):

277

elif line.startswith("# Parent "):

278

parents.append(line[9:].lstrip())

278

parents.append(line[9:].lstrip())

279

elif line.startswith("# "):

279

elif line.startswith("# "):

280

for header, key in patchheadermap:

280

for header, key in patchheadermap:

281

prefix = '# %s ' % header

281

prefix = '# %s ' % header

282

if line.startswith(prefix):

282

if line.startswith(prefix):

283

data[key] = line[len(prefix):]

283

data[key] = line[len(prefix):]

284

else:

284

else:

285

hgpatchheader = False

285

hgpatchheader = False

286

elif line == '---':

286

elif line == '---':

287

ignoretext = True

287

ignoretext = True

288

if not hgpatchheader and not ignoretext:

288

if not hgpatchheader and not ignoretext:

289

cfp.write(line)

289

cfp.write(line)

290

cfp.write('\n')

290

cfp.write('\n')

291

message = cfp.getvalue()

291

message = cfp.getvalue()

292

if tmpfp:

292

if tmpfp:

293

tmpfp.write(payload)

293

tmpfp.write(payload)

294

if not payload.endswith('\n'):

294

if not payload.endswith('\n'):

295

tmpfp.write('\n')

295

tmpfp.write('\n')

296

elif not diffs_seen and message and content_type == 'text/plain':

296

elif not diffs_seen and message and content_type == 'text/plain':

297

message += '\n' + payload

297

message += '\n' + payload

298

except: # re-raises

298

except: # re-raises

299

tmpfp.close()

299

tmpfp.close()

300

os.unlink(tmpname)

300

os.unlink(tmpname)

301

raise

301

raise

302

303

if subject and not message.startswith(subject):

303

if subject and not message.startswith(subject):

304

message = '%s\n%s' % (subject, message)

304

message = '%s\n%s' % (subject, message)

305

data['message'] = message

305

data['message'] = message

306

tmpfp.close()

306

tmpfp.close()

307

if parents:

307

if parents:

308

data['p1'] = parents.pop(0)

308

data['p1'] = parents.pop(0)

309

if parents:

309

if parents:

310

data['p2'] = parents.pop(0)

310

data['p2'] = parents.pop(0)

311

312

if diffs_seen:

312

if diffs_seen:

313

data['filename'] = tmpname

313

data['filename'] = tmpname

314

else:

314

else:

315

os.unlink(tmpname)

315

os.unlink(tmpname)

316

return data

316

return data

317

318

class patchmeta(object):

318

class patchmeta(object):

319

"""Patched file metadata

319

"""Patched file metadata

320

321

'op' is the performed operation within ADD, DELETE, RENAME, MODIFY

321

'op' is the performed operation within ADD, DELETE, RENAME, MODIFY

322

or COPY. 'path' is patched file path. 'oldpath' is set to the

322

or COPY. 'path' is patched file path. 'oldpath' is set to the

323

origin file when 'op' is either COPY or RENAME, None otherwise. If

323

origin file when 'op' is either COPY or RENAME, None otherwise. If

324

file mode is changed, 'mode' is a tuple (islink, isexec) where

324

file mode is changed, 'mode' is a tuple (islink, isexec) where

325

'islink' is True if the file is a symlink and 'isexec' is True if

325

'islink' is True if the file is a symlink and 'isexec' is True if

326

the file is executable. Otherwise, 'mode' is None.

326

the file is executable. Otherwise, 'mode' is None.

327

"""

327

"""

328

def __init__(self, path):

328

def __init__(self, path):

329

self.path = path

329

self.path = path

330

self.oldpath = None

330

self.oldpath = None

331

self.mode = None

331

self.mode = None

332

self.op = 'MODIFY'

332

self.op = 'MODIFY'

333

self.binary = False

333

self.binary = False

334

335

def setmode(self, mode):

335

def setmode(self, mode):

336

islink = mode & 0o20000

336

islink = mode & 0o20000

337

isexec = mode & 0o100

337

isexec = mode & 0o100

338

self.mode = (islink, isexec)

338

self.mode = (islink, isexec)

339

340

def copy(self):

340

def copy(self):

341

other = patchmeta(self.path)

341

other = patchmeta(self.path)

342

other.oldpath = self.oldpath

342

other.oldpath = self.oldpath

343

other.mode = self.mode

343

other.mode = self.mode

344

other.op = self.op

344

other.op = self.op

345

other.binary = self.binary

345

other.binary = self.binary

346

return other

346

return other

347

348

def _ispatchinga(self, afile):

348

def _ispatchinga(self, afile):

349

if afile == '/dev/null':

349

if afile == '/dev/null':

350

return self.op == 'ADD'

350

return self.op == 'ADD'

351

return afile == 'a/' + (self.oldpath or self.path)

351

return afile == 'a/' + (self.oldpath or self.path)

352

353

def _ispatchingb(self, bfile):

353

def _ispatchingb(self, bfile):

354

if bfile == '/dev/null':

354

if bfile == '/dev/null':

355

return self.op == 'DELETE'

355

return self.op == 'DELETE'

356

return bfile == 'b/' + self.path

356

return bfile == 'b/' + self.path

357

358

def ispatching(self, afile, bfile):

358

def ispatching(self, afile, bfile):

359

return self._ispatchinga(afile) and self._ispatchingb(bfile)

359

return self._ispatchinga(afile) and self._ispatchingb(bfile)

360

361

def __repr__(self):

361

def __repr__(self):

362

return "<patchmeta %s %r>" % (self.op, self.path)

362

return "<patchmeta %s %r>" % (self.op, self.path)

363

364

def readgitpatch(lr):

364

def readgitpatch(lr):

365

"""extract git-style metadata about patches from <patchname>"""

365

"""extract git-style metadata about patches from <patchname>"""

366

367

# Filter patch for git information

367

# Filter patch for git information

368

gp = None

368

gp = None

369

gitpatches = []

369

gitpatches = []

370

for line in lr:

370

for line in lr:

371

line = line.rstrip(' \r\n')

371

line = line.rstrip(' \r\n')

372

if line.startswith('diff --git a/'):

372

if line.startswith('diff --git a/'):

373

m = gitre.match(line)

373

m = gitre.match(line)

374

if m:

374

if m:

375

if gp:

375

if gp:

376

gitpatches.append(gp)

376

gitpatches.append(gp)

377

dst = m.group(2)

377

dst = m.group(2)

378

gp = patchmeta(dst)

378

gp = patchmeta(dst)

379

elif gp:

379

elif gp:

380

if line.startswith('--- '):

380

if line.startswith('--- '):

381

gitpatches.append(gp)

381

gitpatches.append(gp)

382

gp = None

382

gp = None

383

continue

383

continue

384

if line.startswith('rename from '):

384

if line.startswith('rename from '):

385

gp.op = 'RENAME'

385

gp.op = 'RENAME'

386

gp.oldpath = line[12:]

386

gp.oldpath = line[12:]

387

elif line.startswith('rename to '):

387

elif line.startswith('rename to '):

388

gp.path = line[10:]

388

gp.path = line[10:]

389

elif line.startswith('copy from '):

389

elif line.startswith('copy from '):

390

gp.op = 'COPY'

390

gp.op = 'COPY'

391

gp.oldpath = line[10:]

391

gp.oldpath = line[10:]

392

elif line.startswith('copy to '):

392

elif line.startswith('copy to '):

393

gp.path = line[8:]

393

gp.path = line[8:]

394

elif line.startswith('deleted file'):

394

elif line.startswith('deleted file'):

395

gp.op = 'DELETE'

395

gp.op = 'DELETE'

396

elif line.startswith('new file mode '):

396

elif line.startswith('new file mode '):

397

gp.op = 'ADD'

397

gp.op = 'ADD'

398

gp.setmode(int(line[-6:], 8))

398

gp.setmode(int(line[-6:], 8))

399

elif line.startswith('new mode '):

399

elif line.startswith('new mode '):

400

gp.setmode(int(line[-6:], 8))

400

gp.setmode(int(line[-6:], 8))

401

elif line.startswith('GIT binary patch'):

401

elif line.startswith('GIT binary patch'):

402

gp.binary = True

402

gp.binary = True

403

if gp:

403

if gp:

404

gitpatches.append(gp)

404

gitpatches.append(gp)

405

406

return gitpatches

406

return gitpatches

407

408

class linereader(object):

408

class linereader(object):

409

# simple class to allow pushing lines back into the input stream

409

# simple class to allow pushing lines back into the input stream

410

def __init__(self, fp):

410

def __init__(self, fp):

411

self.fp = fp

411

self.fp = fp

412

self.buf = []

412

self.buf = []

413

414

def push(self, line):

414

def push(self, line):

415

if line is not None:

415

if line is not None:

416

self.buf.append(line)

416

self.buf.append(line)

417

418

def readline(self):

418

def readline(self):

419

if self.buf:

419

if self.buf:

420

l = self.buf[0]

420

l = self.buf[0]

421

del self.buf[0]

421

del self.buf[0]

422

return l

422

return l

423

return self.fp.readline()

423

return self.fp.readline()

424

425

def __iter__(self):

425

def __iter__(self):

426

return iter(self.readline, '')

426

return iter(self.readline, '')

427

428

class abstractbackend(object):

428

class abstractbackend(object):

429

def __init__(self, ui):

429

def __init__(self, ui):

430

self.ui = ui

430

self.ui = ui

431

432

def getfile(self, fname):

432

def getfile(self, fname):

433

"""Return target file data and flags as a (data, (islink,

433

"""Return target file data and flags as a (data, (islink,

434

isexec)) tuple. Data is None if file is missing/deleted.

434

isexec)) tuple. Data is None if file is missing/deleted.

435

"""

435

"""

436

raise NotImplementedError

436

raise NotImplementedError

437

438

def setfile(self, fname, data, mode, copysource):

438

def setfile(self, fname, data, mode, copysource):

439

"""Write data to target file fname and set its mode. mode is a

439

"""Write data to target file fname and set its mode. mode is a

440

(islink, isexec) tuple. If data is None, the file content should

440

(islink, isexec) tuple. If data is None, the file content should

441

be left unchanged. If the file is modified after being copied,

441

be left unchanged. If the file is modified after being copied,

442

copysource is set to the original file name.

442

copysource is set to the original file name.

443

"""

443

"""

444

raise NotImplementedError

444

raise NotImplementedError

445

446

def unlink(self, fname):

446

def unlink(self, fname):

447

"""Unlink target file."""

447

"""Unlink target file."""

448

raise NotImplementedError

448

raise NotImplementedError

449

450

def writerej(self, fname, failed, total, lines):

450

def writerej(self, fname, failed, total, lines):

451

"""Write rejected lines for fname. total is the number of hunks

451

"""Write rejected lines for fname. total is the number of hunks

452

which failed to apply and total the total number of hunks for this

452

which failed to apply and total the total number of hunks for this

453

files.

453

files.

454

"""

454

"""

455

456

def exists(self, fname):

456

def exists(self, fname):

457

raise NotImplementedError

457

raise NotImplementedError

458

459

def close(self):

459

def close(self):

460

raise NotImplementedError

460

raise NotImplementedError

461

462

class fsbackend(abstractbackend):

462

class fsbackend(abstractbackend):

463

def __init__(self, ui, basedir):

463

def __init__(self, ui, basedir):

464

super(fsbackend, self).__init__(ui)

464

super(fsbackend, self).__init__(ui)

465

self.opener = vfsmod.vfs(basedir)

465

self.opener = vfsmod.vfs(basedir)

466

467

def getfile(self, fname):

467

def getfile(self, fname):

468

if self.opener.islink(fname):

468

if self.opener.islink(fname):

469

return (self.opener.readlink(fname), (True, False))

469

return (self.opener.readlink(fname), (True, False))

470

471

isexec = False

471

isexec = False

472

try:

472

try:

473

isexec = self.opener.lstat(fname).st_mode & 0o100 != 0

473

isexec = self.opener.lstat(fname).st_mode & 0o100 != 0

474

except OSError as e:

474

except OSError as e:

475

if e.errno != errno.ENOENT:

475

if e.errno != errno.ENOENT:

476

raise

476

raise

477

try:

477

try:

478

return (self.opener.read(fname), (False, isexec))

478

return (self.opener.read(fname), (False, isexec))

479

except IOError as e:

479

except IOError as e:

480

if e.errno != errno.ENOENT:

480

if e.errno != errno.ENOENT:

481

raise

481

raise

482

return None, None

482

return None, None

483

484

def setfile(self, fname, data, mode, copysource):

484

def setfile(self, fname, data, mode, copysource):

485

islink, isexec = mode

485

islink, isexec = mode

486

if data is None:

486

if data is None:

487

self.opener.setflags(fname, islink, isexec)

487

self.opener.setflags(fname, islink, isexec)

488

return

488

return

489

if islink:

489

if islink:

490

self.opener.symlink(data, fname)

490

self.opener.symlink(data, fname)

491

else:

491

else:

492

self.opener.write(fname, data)

492

self.opener.write(fname, data)

493

if isexec:

493

if isexec:

494

self.opener.setflags(fname, False, True)

494

self.opener.setflags(fname, False, True)

495

496

def unlink(self, fname):

496

def unlink(self, fname):

497

self.opener.unlinkpath(fname, ignoremissing=True)

497

self.opener.unlinkpath(fname, ignoremissing=True)

498

499

def writerej(self, fname, failed, total, lines):

499

def writerej(self, fname, failed, total, lines):

500

fname = fname + ".rej"

500

fname = fname + ".rej"

501

self.ui.warn(

501

self.ui.warn(

502

_("%d out of %d hunks FAILED -- saving rejects to file %s\n") %

502

_("%d out of %d hunks FAILED -- saving rejects to file %s\n") %

503

(failed, total, fname))

503

(failed, total, fname))

504

fp = self.opener(fname, 'w')

504

fp = self.opener(fname, 'w')

505

fp.writelines(lines)

505

fp.writelines(lines)

506

fp.close()

506

fp.close()

507

508

def exists(self, fname):

508

def exists(self, fname):

509

return self.opener.lexists(fname)

509

return self.opener.lexists(fname)

510

511

class workingbackend(fsbackend):

511

class workingbackend(fsbackend):

512

def __init__(self, ui, repo, similarity):

512

def __init__(self, ui, repo, similarity):

513

super(workingbackend, self).__init__(ui, repo.root)

513

super(workingbackend, self).__init__(ui, repo.root)

514

self.repo = repo

514

self.repo = repo

515

self.similarity = similarity

515

self.similarity = similarity

516

self.removed = set()

516

self.removed = set()

517

self.changed = set()

517

self.changed = set()

518

self.copied = []

518

self.copied = []

519

520

def _checkknown(self, fname):

520

def _checkknown(self, fname):

521

if self.repo.dirstate[fname] == '?' and self.exists(fname):

521

if self.repo.dirstate[fname] == '?' and self.exists(fname):

522

raise PatchError(_('cannot patch %s: file is not tracked') % fname)

522

raise PatchError(_('cannot patch %s: file is not tracked') % fname)

523

524

def setfile(self, fname, data, mode, copysource):

524

def setfile(self, fname, data, mode, copysource):

525

self._checkknown(fname)

525

self._checkknown(fname)

526

super(workingbackend, self).setfile(fname, data, mode, copysource)

526

super(workingbackend, self).setfile(fname, data, mode, copysource)

527

if copysource is not None:

527

if copysource is not None:

528

self.copied.append((copysource, fname))

528

self.copied.append((copysource, fname))

529

self.changed.add(fname)

529

self.changed.add(fname)

530

531

def unlink(self, fname):

531

def unlink(self, fname):

532

self._checkknown(fname)

532

self._checkknown(fname)

533

super(workingbackend, self).unlink(fname)

533

super(workingbackend, self).unlink(fname)

534

self.removed.add(fname)

534

self.removed.add(fname)

535

self.changed.add(fname)

535

self.changed.add(fname)

536

537

def close(self):

537

def close(self):

538

wctx = self.repo[None]

538

wctx = self.repo[None]

539

changed = set(self.changed)

539

changed = set(self.changed)

540

for src, dst in self.copied:

540

for src, dst in self.copied:

541

scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)

541

scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)

542

if self.removed:

542

if self.removed:

543

wctx.forget(sorted(self.removed))

543

wctx.forget(sorted(self.removed))

544

for f in self.removed:

544

for f in self.removed:

545

if f not in self.repo.dirstate:

545

if f not in self.repo.dirstate:

546

# File was deleted and no longer belongs to the

546

# File was deleted and no longer belongs to the

547

# dirstate, it was probably marked added then

547

# dirstate, it was probably marked added then

548

# deleted, and should not be considered by

548

# deleted, and should not be considered by

549

# marktouched().

549

# marktouched().

550

changed.discard(f)

550

changed.discard(f)

551

if changed:

551

if changed:

552

scmutil.marktouched(self.repo, changed, self.similarity)

552

scmutil.marktouched(self.repo, changed, self.similarity)

553

return sorted(self.changed)

553

return sorted(self.changed)

554

555

class filestore(object):

555

class filestore(object):

556

def __init__(self, maxsize=None):

556

def __init__(self, maxsize=None):

557

self.opener = None

557

self.opener = None

558

self.files = {}

558

self.files = {}

559

self.created = 0

559

self.created = 0

560

self.maxsize = maxsize

560

self.maxsize = maxsize

561

if self.maxsize is None:

561

if self.maxsize is None:

562

self.maxsize = 4*(2**20)

562

self.maxsize = 4*(2**20)

563

self.size = 0

563

self.size = 0

564

self.data = {}

564

self.data = {}

565

566

def setfile(self, fname, data, mode, copied=None):

566

def setfile(self, fname, data, mode, copied=None):

567

if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:

567

if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:

568

self.data[fname] = (data, mode, copied)

568

self.data[fname] = (data, mode, copied)

569

self.size += len(data)

569

self.size += len(data)

570

else:

570

else:

571

if self.opener is None:

571

if self.opener is None:

572

root = tempfile.mkdtemp(prefix='hg-patch-')

572

root = tempfile.mkdtemp(prefix='hg-patch-')

573

self.opener = vfsmod.vfs(root)

573

self.opener = vfsmod.vfs(root)

574

# Avoid filename issues with these simple names

574

# Avoid filename issues with these simple names

575

fn = '%d' % self.created

575

fn = '%d' % self.created

576

self.opener.write(fn, data)

576

self.opener.write(fn, data)

577

self.created += 1

577

self.created += 1

578

self.files[fname] = (fn, mode, copied)

578

self.files[fname] = (fn, mode, copied)

579

580

def getfile(self, fname):

580

def getfile(self, fname):

581

if fname in self.data:

581

if fname in self.data:

582

return self.data[fname]

582

return self.data[fname]

583

if not self.opener or fname not in self.files:

583

if not self.opener or fname not in self.files:

584

return None, None, None

584

return None, None, None

585

fn, mode, copied = self.files[fname]

585

fn, mode, copied = self.files[fname]

586

return self.opener.read(fn), mode, copied

586

return self.opener.read(fn), mode, copied

587

588

def close(self):

588

def close(self):

589

if self.opener:

589

if self.opener:

590

shutil.rmtree(self.opener.base)

590

shutil.rmtree(self.opener.base)

591

592

class repobackend(abstractbackend):

592

class repobackend(abstractbackend):

593

def __init__(self, ui, repo, ctx, store):

593

def __init__(self, ui, repo, ctx, store):

594

super(repobackend, self).__init__(ui)

594

super(repobackend, self).__init__(ui)

595

self.repo = repo

595

self.repo = repo

596

self.ctx = ctx

596

self.ctx = ctx

597

self.store = store

597

self.store = store

598

self.changed = set()

598

self.changed = set()

599

self.removed = set()

599

self.removed = set()

600

self.copied = {}

600

self.copied = {}

601

602

def _checkknown(self, fname):

602

def _checkknown(self, fname):

603

if fname not in self.ctx:

603

if fname not in self.ctx:

604

raise PatchError(_('cannot patch %s: file is not tracked') % fname)

604

raise PatchError(_('cannot patch %s: file is not tracked') % fname)

605

606

def getfile(self, fname):

606

def getfile(self, fname):

607

try:

607

try:

608

fctx = self.ctx[fname]

608

fctx = self.ctx[fname]

609

except error.LookupError:

609

except error.LookupError:

610

return None, None

610

return None, None

611

flags = fctx.flags()

611

flags = fctx.flags()

612

return fctx.data(), ('l' in flags, 'x' in flags)

612

return fctx.data(), ('l' in flags, 'x' in flags)

613

614

def setfile(self, fname, data, mode, copysource):

614

def setfile(self, fname, data, mode, copysource):

615

if copysource:

615

if copysource:

616

self._checkknown(copysource)

616

self._checkknown(copysource)

617

if data is None:

617

if data is None:

618

data = self.ctx[fname].data()

618

data = self.ctx[fname].data()

619

self.store.setfile(fname, data, mode, copysource)

619

self.store.setfile(fname, data, mode, copysource)

620

self.changed.add(fname)

620

self.changed.add(fname)

621

if copysource:

621

if copysource:

622

self.copied[fname] = copysource

622

self.copied[fname] = copysource

623

624

def unlink(self, fname):

624

def unlink(self, fname):

625

self._checkknown(fname)

625

self._checkknown(fname)

626

self.removed.add(fname)

626

self.removed.add(fname)

627

628

def exists(self, fname):

628

def exists(self, fname):

629

return fname in self.ctx

629

return fname in self.ctx

630

631

def close(self):

631

def close(self):

632

return self.changed | self.removed

632

return self.changed | self.removed

633

634

# @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1

634

# @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1

635

unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')

635

unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')

636

contextdesc = re.compile('(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')

636

contextdesc = re.compile('(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')

637

eolmodes = ['strict', 'crlf', 'lf', 'auto']

637

eolmodes = ['strict', 'crlf', 'lf', 'auto']

638

639

class patchfile(object):

639

class patchfile(object):

640

def __init__(self, ui, gp, backend, store, eolmode='strict'):

640

def __init__(self, ui, gp, backend, store, eolmode='strict'):

641

self.fname = gp.path

641

self.fname = gp.path

642

self.eolmode = eolmode

642

self.eolmode = eolmode

643

self.eol = None

643

self.eol = None

644

self.backend = backend

644

self.backend = backend

645

self.ui = ui

645

self.ui = ui

646

self.lines = []

646

self.lines = []

647

self.exists = False

647

self.exists = False

648

self.missing = True

648

self.missing = True

649

self.mode = gp.mode

649

self.mode = gp.mode

650

self.copysource = gp.oldpath

650

self.copysource = gp.oldpath

651

self.create = gp.op in ('ADD', 'COPY', 'RENAME')

651

self.create = gp.op in ('ADD', 'COPY', 'RENAME')

652

self.remove = gp.op == 'DELETE'

652

self.remove = gp.op == 'DELETE'

653

if self.copysource is None:

653

if self.copysource is None:

654

data, mode = backend.getfile(self.fname)

654

data, mode = backend.getfile(self.fname)

655

else:

655

else:

656

data, mode = store.getfile(self.copysource)[:2]

656

data, mode = store.getfile(self.copysource)[:2]

657

if data is not None:

657

if data is not None:

658

self.exists = self.copysource is None or backend.exists(self.fname)

658

self.exists = self.copysource is None or backend.exists(self.fname)

659

self.missing = False

659

self.missing = False

660

if data:

660

if data:

661

self.lines = mdiff.splitnewlines(data)

661

self.lines = mdiff.splitnewlines(data)

662

if self.mode is None:

662

if self.mode is None:

663

self.mode = mode

663

self.mode = mode

664

if self.lines:

664

if self.lines:

665

# Normalize line endings

665

# Normalize line endings

666

if self.lines[0].endswith('\r\n'):

666

if self.lines[0].endswith('\r\n'):

667

self.eol = '\r\n'

667

self.eol = '\r\n'

668

elif self.lines[0].endswith('\n'):

668

elif self.lines[0].endswith('\n'):

669

self.eol = '\n'

669

self.eol = '\n'

670

if eolmode != 'strict':

670

if eolmode != 'strict':

671

nlines = []

671

nlines = []

672

for l in self.lines:

672

for l in self.lines:

673

if l.endswith('\r\n'):

673

if l.endswith('\r\n'):

674

l = l[:-2] + '\n'

674

l = l[:-2] + '\n'

675

nlines.append(l)

675

nlines.append(l)

676

self.lines = nlines

676

self.lines = nlines

677

else:

677

else:

678

if self.create:

678

if self.create:

679

self.missing = False

679

self.missing = False

680

if self.mode is None:

680

if self.mode is None:

681

self.mode = (False, False)

681

self.mode = (False, False)

682

if self.missing:

682

if self.missing:

683

self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)

683

self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)

684

self.ui.warn(_("(use '--prefix' to apply patch relative to the "

684

self.ui.warn(_("(use '--prefix' to apply patch relative to the "

685

"current directory)\n"))

685

"current directory)\n"))

686

687

self.hash = {}

687

self.hash = {}

688

self.dirty = 0

688

self.dirty = 0

689

self.offset = 0

689

self.offset = 0

690

self.skew = 0

690

self.skew = 0

691

self.rej = []

691

self.rej = []

692

self.fileprinted = False

692

self.fileprinted = False

693

self.printfile(False)

693

self.printfile(False)

694

self.hunks = 0

694

self.hunks = 0

695

696

def writelines(self, fname, lines, mode):

696

def writelines(self, fname, lines, mode):

697

if self.eolmode == 'auto':

697

if self.eolmode == 'auto':

698

eol = self.eol

698

eol = self.eol

699

elif self.eolmode == 'crlf':

699

elif self.eolmode == 'crlf':

700

eol = '\r\n'

700

eol = '\r\n'

701

else:

701

else:

702

eol = '\n'

702

eol = '\n'

703

704

if self.eolmode != 'strict' and eol and eol != '\n':

704

if self.eolmode != 'strict' and eol and eol != '\n':

705

rawlines = []

705

rawlines = []

706

for l in lines:

706

for l in lines:

707

if l and l[-1] == '\n':

707

if l and l[-1] == '\n':

708

l = l[:-1] + eol

708

l = l[:-1] + eol

709

rawlines.append(l)

709

rawlines.append(l)

710

lines = rawlines

710

lines = rawlines

711

712

self.backend.setfile(fname, ''.join(lines), mode, self.copysource)

712

self.backend.setfile(fname, ''.join(lines), mode, self.copysource)

713

714

def printfile(self, warn):

714

def printfile(self, warn):

715

if self.fileprinted:

715

if self.fileprinted:

716

return

716

return

717

if warn or self.ui.verbose:

717

if warn or self.ui.verbose:

718

self.fileprinted = True

718

self.fileprinted = True

719

s = _("patching file %s\n") % self.fname

719

s = _("patching file %s\n") % self.fname

720

if warn:

720

if warn:

721

self.ui.warn(s)

721

self.ui.warn(s)

722

else:

722

else:

723

self.ui.note(s)

723

self.ui.note(s)

724

725

726

def findlines(self, l, linenum):

726

def findlines(self, l, linenum):

727

# looks through the hash and finds candidate lines. The

727

# looks through the hash and finds candidate lines. The

728

# result is a list of line numbers sorted based on distance

728

# result is a list of line numbers sorted based on distance

729

# from linenum

729

# from linenum

730

731

cand = self.hash.get(l, [])

731

cand = self.hash.get(l, [])

732

if len(cand) > 1:

732

if len(cand) > 1:

733

# resort our list of potentials forward then back.

733

# resort our list of potentials forward then back.

734

cand.sort(key=lambda x: abs(x - linenum))

734

cand.sort(key=lambda x: abs(x - linenum))

735

return cand

735

return cand

736

737

def write_rej(self):

737

def write_rej(self):

738

# our rejects are a little different from patch(1). This always

738

# our rejects are a little different from patch(1). This always

739

# creates rejects in the same form as the original patch. A file

739

# creates rejects in the same form as the original patch. A file

740

# header is inserted so that you can run the reject through patch again

740

# header is inserted so that you can run the reject through patch again

741

# without having to type the filename.

741

# without having to type the filename.

742

if not self.rej:

742

if not self.rej:

743

return

743

return

744

base = os.path.basename(self.fname)

744

base = os.path.basename(self.fname)

745

lines = ["--- %s\n+++ %s\n" % (base, base)]

745

lines = ["--- %s\n+++ %s\n" % (base, base)]

746

for x in self.rej:

746

for x in self.rej:

747

for l in x.hunk:

747

for l in x.hunk:

748

lines.append(l)

748

lines.append(l)

749

if l[-1:] != '\n':

749

if l[-1:] != '\n':

750

lines.append("\n\ No newline at end of file\n")

750

lines.append("\n\ No newline at end of file\n")

751

self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)

751

self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)

752

753

def apply(self, h):

753

def apply(self, h):

754

if not h.complete():

754

if not h.complete():

755

raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %

755

raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %

756

(h.number, h.desc, len(h.a), h.lena, len(h.b),

756

(h.number, h.desc, len(h.a), h.lena, len(h.b),

757

h.lenb))

757

h.lenb))

758

759

self.hunks += 1

759

self.hunks += 1

760

761

if self.missing:

761

if self.missing:

762

self.rej.append(h)

762

self.rej.append(h)

763

return -1

763

return -1

764

765

if self.exists and self.create:

765

if self.exists and self.create:

766

if self.copysource:

766

if self.copysource:

767

self.ui.warn(_("cannot create %s: destination already "

767

self.ui.warn(_("cannot create %s: destination already "

768

"exists\n") % self.fname)

768

"exists\n") % self.fname)

769

else:

769

else:

770

self.ui.warn(_("file %s already exists\n") % self.fname)

770

self.ui.warn(_("file %s already exists\n") % self.fname)

771

self.rej.append(h)

771

self.rej.append(h)

772

return -1

772

return -1

773

774

if isinstance(h, binhunk):

774

if isinstance(h, binhunk):

775

if self.remove:

775

if self.remove:

776

self.backend.unlink(self.fname)

776

self.backend.unlink(self.fname)

777

else:

777

else:

778

l = h.new(self.lines)

778

l = h.new(self.lines)

779

self.lines[:] = l

779

self.lines[:] = l

780

self.offset += len(l)

780

self.offset += len(l)

781

self.dirty = True

781

self.dirty = True

782

return 0

782

return 0

783

784

horig = h

784

horig = h

785

if (self.eolmode in ('crlf', 'lf')

785

if (self.eolmode in ('crlf', 'lf')

786

or self.eolmode == 'auto' and self.eol):

786

or self.eolmode == 'auto' and self.eol):

787

# If new eols are going to be normalized, then normalize

787

# If new eols are going to be normalized, then normalize

788

# hunk data before patching. Otherwise, preserve input

788

# hunk data before patching. Otherwise, preserve input

789

# line-endings.

789

# line-endings.

790

h = h.getnormalized()

790

h = h.getnormalized()

791

792

# fast case first, no offsets, no fuzz

792

# fast case first, no offsets, no fuzz

793

old, oldstart, new, newstart = h.fuzzit(0, False)

793

old, oldstart, new, newstart = h.fuzzit(0, False)

794

oldstart += self.offset

794

oldstart += self.offset

795

orig_start = oldstart

795

orig_start = oldstart

796

# if there's skew we want to emit the "(offset %d lines)" even

796

# if there's skew we want to emit the "(offset %d lines)" even

797

# when the hunk cleanly applies at start + skew, so skip the

797

# when the hunk cleanly applies at start + skew, so skip the

798

# fast case code

798

# fast case code

799

if (self.skew == 0 and

799

if (self.skew == 0 and

800

diffhelpers.testhunk(old, self.lines, oldstart) == 0):

800

diffhelpers.testhunk(old, self.lines, oldstart) == 0):

801

if self.remove:

801

if self.remove:

802

self.backend.unlink(self.fname)

802

self.backend.unlink(self.fname)

803

else:

803

else:

804

self.lines[oldstart:oldstart + len(old)] = new

804

self.lines[oldstart:oldstart + len(old)] = new

805

self.offset += len(new) - len(old)

805

self.offset += len(new) - len(old)

806

self.dirty = True

806

self.dirty = True

807

return 0

807

return 0

808

809

# ok, we couldn't match the hunk. Lets look for offsets and fuzz it

809

# ok, we couldn't match the hunk. Lets look for offsets and fuzz it

810

self.hash = {}

810

self.hash = {}

811

for x, s in enumerate(self.lines):

811

for x, s in enumerate(self.lines):

812

self.hash.setdefault(s, []).append(x)

812

self.hash.setdefault(s, []).append(x)

813

814

for fuzzlen in xrange(self.ui.configint("patch", "fuzz") + 1):

814

for fuzzlen in xrange(self.ui.configint("patch", "fuzz") + 1):

815

for toponly in [True, False]:

815

for toponly in [True, False]:

816

old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)

816

old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)

817

oldstart = oldstart + self.offset + self.skew

817

oldstart = oldstart + self.offset + self.skew

818

oldstart = min(oldstart, len(self.lines))

818

oldstart = min(oldstart, len(self.lines))

819

if old:

819

if old:

820

cand = self.findlines(old[0][1:], oldstart)

820

cand = self.findlines(old[0][1:], oldstart)

821

else:

821

else:

822

# Only adding lines with no or fuzzed context, just

822

# Only adding lines with no or fuzzed context, just

823

# take the skew in account

823

# take the skew in account

824

cand = [oldstart]

824

cand = [oldstart]

825

826

for l in cand:

826

for l in cand:

827

if not old or diffhelpers.testhunk(old, self.lines, l) == 0:

827

if not old or diffhelpers.testhunk(old, self.lines, l) == 0:

828

self.lines[l : l + len(old)] = new

828

self.lines[l : l + len(old)] = new

829

self.offset += len(new) - len(old)

829

self.offset += len(new) - len(old)

830

self.skew = l - orig_start

830

self.skew = l - orig_start

831

self.dirty = True

831

self.dirty = True

832

offset = l - orig_start - fuzzlen

832

offset = l - orig_start - fuzzlen

833

if fuzzlen:

833

if fuzzlen:

834

msg = _("Hunk #%d succeeded at %d "

834

msg = _("Hunk #%d succeeded at %d "

835

"with fuzz %d "

835

"with fuzz %d "

836

"(offset %d lines).\n")

836

"(offset %d lines).\n")

837

self.printfile(True)

837

self.printfile(True)

838

self.ui.warn(msg %

838

self.ui.warn(msg %

839

(h.number, l + 1, fuzzlen, offset))

839

(h.number, l + 1, fuzzlen, offset))

840

else:

840

else:

841

msg = _("Hunk #%d succeeded at %d "

841

msg = _("Hunk #%d succeeded at %d "

842

"(offset %d lines).\n")

842

"(offset %d lines).\n")

843

self.ui.note(msg % (h.number, l + 1, offset))

843

self.ui.note(msg % (h.number, l + 1, offset))

844

return fuzzlen

844

return fuzzlen

845

self.printfile(True)

845

self.printfile(True)

846

self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))

846

self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))

847

self.rej.append(horig)

847

self.rej.append(horig)

848

return -1

848

return -1

849

850

def close(self):

850

def close(self):

851

if self.dirty:

851

if self.dirty:

852

self.writelines(self.fname, self.lines, self.mode)

852

self.writelines(self.fname, self.lines, self.mode)

853

self.write_rej()

853

self.write_rej()

854

return len(self.rej)

854

return len(self.rej)

855

856

class header(object):

856

class header(object):

857

"""patch header

857

"""patch header

858

"""

858

"""

859

diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')

859

diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')

860

diff_re = re.compile('diff -r .* (.*)$')

860

diff_re = re.compile('diff -r .* (.*)$')

861

allhunks_re = re.compile('(?:index|deleted file) ')

861

allhunks_re = re.compile('(?:index|deleted file) ')

862

pretty_re = re.compile('(?:new file|deleted file) ')

862

pretty_re = re.compile('(?:new file|deleted file) ')

863

special_re = re.compile('(?:index|deleted|copy|rename) ')

863

special_re = re.compile('(?:index|deleted|copy|rename) ')

864

newfile_re = re.compile('(?:new file)')

864

newfile_re = re.compile('(?:new file)')

865

866

def __init__(self, header):

866

def __init__(self, header):

867

self.header = header

867

self.header = header

868

self.hunks = []

868

self.hunks = []

869

870

def binary(self):

870

def binary(self):

871

return any(h.startswith('index ') for h in self.header)

871

return any(h.startswith('index ') for h in self.header)

872

873

def pretty(self, fp):

873

def pretty(self, fp):

874

for h in self.header:

874

for h in self.header:

875

if h.startswith('index '):

875

if h.startswith('index '):

876

fp.write(_('this modifies a binary file (all or nothing)\n'))

876

fp.write(_('this modifies a binary file (all or nothing)\n'))

877

break

877

break

878

if self.pretty_re.match(h):

878

if self.pretty_re.match(h):

879

fp.write(h)

879

fp.write(h)

880

if self.binary():

880

if self.binary():

881

fp.write(_('this is a binary file\n'))

881

fp.write(_('this is a binary file\n'))

882

break

882

break

883

if h.startswith('---'):

883

if h.startswith('---'):

884

fp.write(_('%d hunks, %d lines changed\n') %

884

fp.write(_('%d hunks, %d lines changed\n') %

885

(len(self.hunks),

885

(len(self.hunks),

886

sum([max(h.added, h.removed) for h in self.hunks])))

886

sum([max(h.added, h.removed) for h in self.hunks])))

887

break

887

break

888

fp.write(h)

888

fp.write(h)

889

890

def write(self, fp):

890

def write(self, fp):

891

fp.write(''.join(self.header))

891

fp.write(''.join(self.header))

892

893

def allhunks(self):

893

def allhunks(self):

894

return any(self.allhunks_re.match(h) for h in self.header)

894

return any(self.allhunks_re.match(h) for h in self.header)

895

896

def files(self):

896

def files(self):

897

match = self.diffgit_re.match(self.header[0])

897

match = self.diffgit_re.match(self.header[0])

898

if match:

898

if match:

899

fromfile, tofile = match.groups()

899

fromfile, tofile = match.groups()

900

if fromfile == tofile:

900

if fromfile == tofile:

901

return [fromfile]

901

return [fromfile]

902

return [fromfile, tofile]

902

return [fromfile, tofile]

903

else:

903

else:

904

return self.diff_re.match(self.header[0]).groups()

904

return self.diff_re.match(self.header[0]).groups()

905

906

def filename(self):

906

def filename(self):

907

return self.files()[-1]

907

return self.files()[-1]

908

909

def __repr__(self):

909

def __repr__(self):

910

return '<header %s>' % (' '.join(map(repr, self.files())))

910

return '<header %s>' % (' '.join(map(repr, self.files())))

911

912

def isnewfile(self):

912

def isnewfile(self):

913

return any(self.newfile_re.match(h) for h in self.header)

913

return any(self.newfile_re.match(h) for h in self.header)

914

915

def special(self):

915

def special(self):

916

# Special files are shown only at the header level and not at the hunk

916

# Special files are shown only at the header level and not at the hunk

917

# level for example a file that has been deleted is a special file.

917

# level for example a file that has been deleted is a special file.

918

# The user cannot change the content of the operation, in the case of

918

# The user cannot change the content of the operation, in the case of

919

# the deleted file he has to take the deletion or not take it, he

919

# the deleted file he has to take the deletion or not take it, he

920

# cannot take some of it.

920

# cannot take some of it.

921

# Newly added files are special if they are empty, they are not special

921

# Newly added files are special if they are empty, they are not special

922

# if they have some content as we want to be able to change it

922

# if they have some content as we want to be able to change it

923

nocontent = len(self.header) == 2

923

nocontent = len(self.header) == 2

924

emptynewfile = self.isnewfile() and nocontent

924

emptynewfile = self.isnewfile() and nocontent

925

return emptynewfile or \

925

return emptynewfile or \

926

any(self.special_re.match(h) for h in self.header)

926

any(self.special_re.match(h) for h in self.header)

927

928

class recordhunk(object):

928

class recordhunk(object):

929

"""patch hunk

929

"""patch hunk

930

931

XXX shouldn't we merge this with the other hunk class?

931

XXX shouldn't we merge this with the other hunk class?

932

"""

932

"""

933

934

def __init__(self, header, fromline, toline, proc, before, hunk, after,

934

def __init__(self, header, fromline, toline, proc, before, hunk, after,

935

maxcontext=None):

935

maxcontext=None):

936

def trimcontext(lines, reverse=False):

936

def trimcontext(lines, reverse=False):

937

if maxcontext is not None:

937

if maxcontext is not None:

938

delta = len(lines) - maxcontext

938

delta = len(lines) - maxcontext

939

if delta > 0:

939

if delta > 0:

940

if reverse:

940

if reverse:

941

return delta, lines[delta:]

941

return delta, lines[delta:]

942

else:

942

else:

943

return delta, lines[:maxcontext]

943

return delta, lines[:maxcontext]

944

return 0, lines

944

return 0, lines

945

946

self.header = header

946

self.header = header

947

trimedbefore, self.before = trimcontext(before, True)

947

trimedbefore, self.before = trimcontext(before, True)

948

self.fromline = fromline + trimedbefore

948

self.fromline = fromline + trimedbefore

949

self.toline = toline + trimedbefore

949

self.toline = toline + trimedbefore

950

_trimedafter, self.after = trimcontext(after, False)

950

_trimedafter, self.after = trimcontext(after, False)

951

self.proc = proc

951

self.proc = proc

952

self.hunk = hunk

952

self.hunk = hunk

953

self.added, self.removed = self.countchanges(self.hunk)

953

self.added, self.removed = self.countchanges(self.hunk)

954

955

def __eq__(self, v):

955

def __eq__(self, v):

956

if not isinstance(v, recordhunk):

956

if not isinstance(v, recordhunk):

957

return False

957

return False

958

959

return ((v.hunk == self.hunk) and

959

return ((v.hunk == self.hunk) and

960

(v.proc == self.proc) and

960

(v.proc == self.proc) and

961

(self.fromline == v.fromline) and

961

(self.fromline == v.fromline) and

962

(self.header.files() == v.header.files()))

962

(self.header.files() == v.header.files()))

963

964

def __hash__(self):

964

def __hash__(self):

965

return hash((tuple(self.hunk),

965

return hash((tuple(self.hunk),

966

tuple(self.header.files()),

966

tuple(self.header.files()),

967

self.fromline,

967

self.fromline,

968

self.proc))

968

self.proc))

969

970

def countchanges(self, hunk):

970

def countchanges(self, hunk):

971

"""hunk -> (n+,n-)"""

971

"""hunk -> (n+,n-)"""

972

add = len([h for h in hunk if h.startswith('+')])

972

add = len([h for h in hunk if h.startswith('+')])

973

rem = len([h for h in hunk if h.startswith('-')])

973

rem = len([h for h in hunk if h.startswith('-')])

974

return add, rem

974

return add, rem

975

976

def reversehunk(self):

976

def reversehunk(self):

977

"""return another recordhunk which is the reverse of the hunk

977

"""return another recordhunk which is the reverse of the hunk

978

979

If this hunk is diff(A, B), the returned hunk is diff(B, A). To do

979

If this hunk is diff(A, B), the returned hunk is diff(B, A). To do

980

that, swap fromline/toline and +/- signs while keep other things

980

that, swap fromline/toline and +/- signs while keep other things

981

unchanged.

981

unchanged.

982

"""

982

"""

983

m = {'+': '-', '-': '+', '\\': '\\'}

983

m = {'+': '-', '-': '+', '\\': '\\'}

984

hunk = ['%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk]

984

hunk = ['%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk]

985

return recordhunk(self.header, self.toline, self.fromline, self.proc,

985

return recordhunk(self.header, self.toline, self.fromline, self.proc,

986

self.before, hunk, self.after)

986

self.before, hunk, self.after)

987

988

def write(self, fp):

988

def write(self, fp):

989

delta = len(self.before) + len(self.after)

989

delta = len(self.before) + len(self.after)

990

if self.after and self.after[-1] == '\\ No newline at end of file\n':

990

if self.after and self.after[-1] == '\\ No newline at end of file\n':

991

delta -= 1

991

delta -= 1

992

fromlen = delta + self.removed

992

fromlen = delta + self.removed

993

tolen = delta + self.added

993

tolen = delta + self.added

994

fp.write('@@ -%d,%d +%d,%d @@%s\n' %

994

fp.write('@@ -%d,%d +%d,%d @@%s\n' %

995

(self.fromline, fromlen, self.toline, tolen,

995

(self.fromline, fromlen, self.toline, tolen,

996

self.proc and (' ' + self.proc)))

996

self.proc and (' ' + self.proc)))

997

fp.write(''.join(self.before + self.hunk + self.after))

997

fp.write(''.join(self.before + self.hunk + self.after))

998

999

pretty = write

999

pretty = write

1000

1001

def filename(self):

1001

def filename(self):

1002

return self.header.filename()

1002

return self.header.filename()

1003

1004

def __repr__(self):

1004

def __repr__(self):

1005

return '<hunk %r@%d>' % (self.filename(), self.fromline)

1005

return '<hunk %r@%d>' % (self.filename(), self.fromline)

1006

1007

def getmessages():

1007

def getmessages():

1008

return {

1008

return {

1009

'multiple': {

1009

'multiple': {

1010

'apply': _("apply change %d/%d to '%s'?"),

1010

'apply': _("apply change %d/%d to '%s'?"),

1011

'discard': _("discard change %d/%d to '%s'?"),

1011

'discard': _("discard change %d/%d to '%s'?"),

1012

'record': _("record change %d/%d to '%s'?"),

1012

'record': _("record change %d/%d to '%s'?"),

1013

},

1013

},

1014

'single': {

1014

'single': {

1015

'apply': _("apply this change to '%s'?"),

1015

'apply': _("apply this change to '%s'?"),

1016

'discard': _("discard this change to '%s'?"),

1016

'discard': _("discard this change to '%s'?"),

1017

'record': _("record this change to '%s'?"),

1017

'record': _("record this change to '%s'?"),

1018

},

1018

},

1019

'help': {

1019

'help': {

1020

'apply': _('[Ynesfdaq?]'

1020

'apply': _('[Ynesfdaq?]'

1021

'$$ &Yes, apply this change'

1021

'$$ &Yes, apply this change'

1022

'$$ &No, skip this change'

1022

'$$ &No, skip this change'

1023

'$$ &Edit this change manually'

1023

'$$ &Edit this change manually'

1024

'$$ &Skip remaining changes to this file'

1024

'$$ &Skip remaining changes to this file'

1025

'$$ Apply remaining changes to this &file'

1025

'$$ Apply remaining changes to this &file'

1026

'$$ &Done, skip remaining changes and files'

1026

'$$ &Done, skip remaining changes and files'

1027

'$$ Apply &all changes to all remaining files'

1027

'$$ Apply &all changes to all remaining files'

1028

'$$ &Quit, applying no changes'

1028

'$$ &Quit, applying no changes'

1029

'$$ &? (display help)'),

1029

'$$ &? (display help)'),

1030

'discard': _('[Ynesfdaq?]'

1030

'discard': _('[Ynesfdaq?]'

1031

'$$ &Yes, discard this change'

1031

'$$ &Yes, discard this change'

1032

'$$ &No, skip this change'

1032

'$$ &No, skip this change'

1033

'$$ &Edit this change manually'

1033

'$$ &Edit this change manually'

1034

'$$ &Skip remaining changes to this file'

1034

'$$ &Skip remaining changes to this file'

1035

'$$ Discard remaining changes to this &file'

1035

'$$ Discard remaining changes to this &file'

1036

'$$ &Done, skip remaining changes and files'

1036

'$$ &Done, skip remaining changes and files'

1037

'$$ Discard &all changes to all remaining files'

1037

'$$ Discard &all changes to all remaining files'

1038

'$$ &Quit, discarding no changes'

1038

'$$ &Quit, discarding no changes'

1039

'$$ &? (display help)'),

1039

'$$ &? (display help)'),

1040

'record': _('[Ynesfdaq?]'

1040

'record': _('[Ynesfdaq?]'

1041

'$$ &Yes, record this change'

1041

'$$ &Yes, record this change'

1042

'$$ &No, skip this change'

1042

'$$ &No, skip this change'

1043

'$$ &Edit this change manually'

1043

'$$ &Edit this change manually'

1044

'$$ &Skip remaining changes to this file'

1044

'$$ &Skip remaining changes to this file'

1045

'$$ Record remaining changes to this &file'

1045

'$$ Record remaining changes to this &file'

1046

'$$ &Done, skip remaining changes and files'

1046

'$$ &Done, skip remaining changes and files'

1047

'$$ Record &all changes to all remaining files'

1047

'$$ Record &all changes to all remaining files'

1048

'$$ &Quit, recording no changes'

1048

'$$ &Quit, recording no changes'

1049

'$$ &? (display help)'),

1049

'$$ &? (display help)'),

1050

}

1050

}

1051

}

1051

}

1052

1053

def filterpatch(ui, headers, operation=None):

1053

def filterpatch(ui, headers, operation=None):

1054

"""Interactively filter patch chunks into applied-only chunks"""

1054

"""Interactively filter patch chunks into applied-only chunks"""

1055

messages = getmessages()

1055

messages = getmessages()

1056

1057

if operation is None:

1057

if operation is None:

1058

operation = 'record'

1058

operation = 'record'

1059

1060

def prompt(skipfile, skipall, query, chunk):

1060

def prompt(skipfile, skipall, query, chunk):

1061

"""prompt query, and process base inputs

1061

"""prompt query, and process base inputs

1062

1063

- y/n for the rest of file

1063

- y/n for the rest of file

1064

- y/n for the rest

1064

- y/n for the rest

1065

- ? (help)

1065

- ? (help)

1066

- q (quit)

1066

- q (quit)

1067

1068

Return True/False and possibly updated skipfile and skipall.

1068

Return True/False and possibly updated skipfile and skipall.

1069

"""

1069

"""

1070

newpatches = None

1070

newpatches = None

1071

if skipall is not None:

1071

if skipall is not None:

1072

return skipall, skipfile, skipall, newpatches

1072

return skipall, skipfile, skipall, newpatches

1073

if skipfile is not None:

1073

if skipfile is not None:

1074

return skipfile, skipfile, skipall, newpatches

1074

return skipfile, skipfile, skipall, newpatches

1075

while True:

1075

while True:

1076

resps = messages['help'][operation]

1076

resps = messages['help'][operation]

1077

r = ui.promptchoice("%s %s" % (query, resps))

1077

r = ui.promptchoice("%s %s" % (query, resps))

1078

ui.write("\n")

1078

ui.write("\n")

1079

if r == 8: # ?

1079

if r == 8: # ?

1080

for c, t in ui.extractchoices(resps)[1]:

1080

for c, t in ui.extractchoices(resps)[1]:

1081

ui.write('%s - %s\n' % (c, encoding.lower(t)))

1081

ui.write('%s - %s\n' % (c, encoding.lower(t)))

1082

continue

1082

continue

1083

elif r == 0: # yes

1083

elif r == 0: # yes

1084

ret = True

1084

ret = True

1085

elif r == 1: # no

1085

elif r == 1: # no

1086

ret = False

1086

ret = False

1087

elif r == 2: # Edit patch

1087

elif r == 2: # Edit patch

1088

if chunk is None:

1088

if chunk is None:

1089

ui.write(_('cannot edit patch for whole file'))

1089

ui.write(_('cannot edit patch for whole file'))

1090

ui.write("\n")

1090

ui.write("\n")

1091

continue

1091

continue

1092

if chunk.header.binary():

1092

if chunk.header.binary():

1093

ui.write(_('cannot edit patch for binary file'))

1093

ui.write(_('cannot edit patch for binary file'))

1094

ui.write("\n")

1094

ui.write("\n")

1095

continue

1095

continue

1096

# Patch comment based on the Git one (based on comment at end of

1096

# Patch comment based on the Git one (based on comment at end of

1097

# https://mercurial-scm.org/wiki/RecordExtension)

1097

# https://mercurial-scm.org/wiki/RecordExtension)

1098

phelp = '---' + _("""

1098

phelp = '---' + _("""

1099

To remove '-' lines, make them ' ' lines (context).

1099

To remove '-' lines, make them ' ' lines (context).

1100

To remove '+' lines, delete them.

1100

To remove '+' lines, delete them.

1101

Lines starting with # will be removed from the patch.

1101

Lines starting with # will be removed from the patch.

1102

1103

If the patch applies cleanly, the edited hunk will immediately be

1103

If the patch applies cleanly, the edited hunk will immediately be

1104

added to the record list. If it does not apply cleanly, a rejects

1104

added to the record list. If it does not apply cleanly, a rejects

1105

file will be generated: you can use that when you try again. If

1105

file will be generated: you can use that when you try again. If

1106

all lines of the hunk are removed, then the edit is aborted and

1106

all lines of the hunk are removed, then the edit is aborted and

1107

the hunk is left unchanged.

1107

the hunk is left unchanged.

1108

""")

1108

""")

1109

(patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-",

1109

(patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-",

1110

suffix=".diff")

1110

suffix=".diff")

1111

ncpatchfp = None

1111

ncpatchfp = None

1112

try:

1112

try:

1113

# Write the initial patch

1113

# Write the initial patch

1114

f = util.nativeeolwriter(os.fdopen(patchfd, r'wb'))

1114

f = util.nativeeolwriter(os.fdopen(patchfd, r'wb'))

1115

chunk.header.write(f)

1115

chunk.header.write(f)

1116

chunk.write(f)

1116

chunk.write(f)

1117

f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))

1117

f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))

1118

f.close()

1118

f.close()

1119

# Start the editor and wait for it to complete

1119

# Start the editor and wait for it to complete

1120

editor = ui.geteditor()

1120

editor = ui.geteditor()

1121

ret = ui.system("%s \"%s\"" % (editor, patchfn),

1121

ret = ui.system("%s \"%s\"" % (editor, patchfn),

1122

environ={'HGUSER': ui.username()},

1122

environ={'HGUSER': ui.username()},

1123

blockedtag='filterpatch')

1123

blockedtag='filterpatch')

1124

if ret != 0:

1124

if ret != 0:

1125

ui.warn(_("editor exited with exit code %d\n") % ret)

1125

ui.warn(_("editor exited with exit code %d\n") % ret)

1126

continue

1126

continue

1127

# Remove comment lines

1127

# Remove comment lines

1128

patchfp = open(patchfn, r'rb')

1128

patchfp = open(patchfn, r'rb')

1129

ncpatchfp = stringio()

1129

ncpatchfp = stringio()

1130

for line in util.iterfile(patchfp):

1130

for line in util.iterfile(patchfp):

1131

line = util.fromnativeeol(line)

1131

line = util.fromnativeeol(line)

1132

if not line.startswith('#'):

1132

if not line.startswith('#'):

1133

ncpatchfp.write(line)

1133

ncpatchfp.write(line)

1134

patchfp.close()

1134

patchfp.close()

1135

ncpatchfp.seek(0)

1135

ncpatchfp.seek(0)

1136

newpatches = parsepatch(ncpatchfp)

1136

newpatches = parsepatch(ncpatchfp)

1137

finally:

1137

finally:

1138

os.unlink(patchfn)

1138

os.unlink(patchfn)

1139

del ncpatchfp

1139

del ncpatchfp

1140

# Signal that the chunk shouldn't be applied as-is, but

1140

# Signal that the chunk shouldn't be applied as-is, but

1141

# provide the new patch to be used instead.

1141

# provide the new patch to be used instead.

1142

ret = False

1142

ret = False

1143

elif r == 3: # Skip

1143

elif r == 3: # Skip

1144

ret = skipfile = False

1144

ret = skipfile = False

1145

elif r == 4: # file (Record remaining)

1145

elif r == 4: # file (Record remaining)

1146

ret = skipfile = True

1146

ret = skipfile = True

1147

elif r == 5: # done, skip remaining

1147

elif r == 5: # done, skip remaining

1148

ret = skipall = False

1148

ret = skipall = False

1149

elif r == 6: # all

1149

elif r == 6: # all

1150

ret = skipall = True

1150

ret = skipall = True

1151

elif r == 7: # quit

1151

elif r == 7: # quit

1152

raise error.Abort(_('user quit'))

1152

raise error.Abort(_('user quit'))

1153

return ret, skipfile, skipall, newpatches

1153

return ret, skipfile, skipall, newpatches

1154

1155

seen = set()

1155

seen = set()

1156

applied = {} # 'filename' -> [] of chunks

1156

applied = {} # 'filename' -> [] of chunks

1157

skipfile, skipall = None, None

1157

skipfile, skipall = None, None

1158

pos, total = 1, sum(len(h.hunks) for h in headers)

1158

pos, total = 1, sum(len(h.hunks) for h in headers)

1159

for h in headers:

1159

for h in headers:

1160

pos += len(h.hunks)

1160

pos += len(h.hunks)

1161

skipfile = None

1161

skipfile = None

1162

fixoffset = 0

1162

fixoffset = 0

1163

hdr = ''.join(h.header)

1163

hdr = ''.join(h.header)

1164

if hdr in seen:

1164

if hdr in seen:

1165

continue

1165

continue

1166

seen.add(hdr)

1166

seen.add(hdr)

1167

if skipall is None:

1167

if skipall is None:

1168

h.pretty(ui)

1168

h.pretty(ui)

1169

msg = (_('examine changes to %s?') %

1169

msg = (_('examine changes to %s?') %

1170

_(' and ').join("'%s'" % f for f in h.files()))

1170

_(' and ').join("'%s'" % f for f in h.files()))

1171

r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)

1171

r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)

1172

if not r:

1172

if not r:

1173

continue

1173

continue

1174

applied[h.filename()] = [h]

1174

applied[h.filename()] = [h]

1175

if h.allhunks():

1175

if h.allhunks():

1176

applied[h.filename()] += h.hunks

1176

applied[h.filename()] += h.hunks

1177

continue

1177

continue

1178

for i, chunk in enumerate(h.hunks):

1178

for i, chunk in enumerate(h.hunks):

1179

if skipfile is None and skipall is None:

1179

if skipfile is None and skipall is None:

1180

chunk.pretty(ui)

1180

chunk.pretty(ui)

1181

if total == 1:

1181

if total == 1:

1182

msg = messages['single'][operation] % chunk.filename()

1182

msg = messages['single'][operation] % chunk.filename()

1183

else:

1183

else:

1184

idx = pos - len(h.hunks) + i

1184

idx = pos - len(h.hunks) + i

1185

msg = messages['multiple'][operation] % (idx, total,

1185

msg = messages['multiple'][operation] % (idx, total,

1186

chunk.filename())

1186

chunk.filename())

1187

r, skipfile, skipall, newpatches = prompt(skipfile,

1187

r, skipfile, skipall, newpatches = prompt(skipfile,

1188

skipall, msg, chunk)

1188

skipall, msg, chunk)

1189

if r:

1189

if r:

1190

if fixoffset:

1190

if fixoffset:

1191

chunk = copy.copy(chunk)

1191

chunk = copy.copy(chunk)

1192

chunk.toline += fixoffset

1192

chunk.toline += fixoffset

1193

applied[chunk.filename()].append(chunk)

1193

applied[chunk.filename()].append(chunk)

1194

elif newpatches is not None:

1194

elif newpatches is not None:

1195

for newpatch in newpatches:

1195

for newpatch in newpatches:

1196

for newhunk in newpatch.hunks:

1196

for newhunk in newpatch.hunks:

1197

if fixoffset:

1197

if fixoffset:

1198

newhunk.toline += fixoffset

1198

newhunk.toline += fixoffset

1199

applied[newhunk.filename()].append(newhunk)

1199

applied[newhunk.filename()].append(newhunk)

1200

else:

1200

else:

1201

fixoffset += chunk.removed - chunk.added

1201

fixoffset += chunk.removed - chunk.added

1202

return (sum([h for h in applied.itervalues()

1202

return (sum([h for h in applied.itervalues()

1203

if h[0].special() or len(h) > 1], []), {})

1203

if h[0].special() or len(h) > 1], []), {})

1204

class hunk(object):

1204

class hunk(object):

1205

def __init__(self, desc, num, lr, context):

1205

def __init__(self, desc, num, lr, context):

1206

self.number = num

1206

self.number = num

1207

self.desc = desc

1207

self.desc = desc

1208

self.hunk = [desc]

1208

self.hunk = [desc]

1209

self.a = []

1209

self.a = []

1210

self.b = []

1210

self.b = []

1211

self.starta = self.lena = None

1211

self.starta = self.lena = None

1212

self.startb = self.lenb = None

1212

self.startb = self.lenb = None

1213

if lr is not None:

1213

if lr is not None:

1214

if context:

1214

if context:

1215

self.read_context_hunk(lr)

1215

self.read_context_hunk(lr)

1216

else:

1216

else:

1217

self.read_unified_hunk(lr)

1217

self.read_unified_hunk(lr)

1218

1219

def getnormalized(self):

1219

def getnormalized(self):

1220

"""Return a copy with line endings normalized to LF."""

1220

"""Return a copy with line endings normalized to LF."""

1221

1222

def normalize(lines):

1222

def normalize(lines):

1223

nlines = []

1223

nlines = []

1224

for line in lines:

1224

for line in lines:

1225

if line.endswith('\r\n'):

1225

if line.endswith('\r\n'):

1226

line = line[:-2] + '\n'

1226

line = line[:-2] + '\n'

1227

nlines.append(line)

1227

nlines.append(line)

1228

return nlines

1228

return nlines

1229

1230

# Dummy object, it is rebuilt manually

1230

# Dummy object, it is rebuilt manually

1231

nh = hunk(self.desc, self.number, None, None)

1231

nh = hunk(self.desc, self.number, None, None)

1232

nh.number = self.number

1232

nh.number = self.number

1233

nh.desc = self.desc

1233

nh.desc = self.desc

1234

nh.hunk = self.hunk

1234

nh.hunk = self.hunk

1235

nh.a = normalize(self.a)

1235

nh.a = normalize(self.a)

1236

nh.b = normalize(self.b)

1236

nh.b = normalize(self.b)

1237

nh.starta = self.starta

1237

nh.starta = self.starta

1238

nh.startb = self.startb

1238

nh.startb = self.startb

1239

nh.lena = self.lena

1239

nh.lena = self.lena

1240

nh.lenb = self.lenb

1240

nh.lenb = self.lenb

1241

return nh

1241

return nh

1242

1243

def read_unified_hunk(self, lr):

1243

def read_unified_hunk(self, lr):

1244

m = unidesc.match(self.desc)

1244

m = unidesc.match(self.desc)

1245

if not m:

1245

if not m:

1246

raise PatchError(_("bad hunk #%d") % self.number)

1246

raise PatchError(_("bad hunk #%d") % self.number)

1247

self.starta, self.lena, self.startb, self.lenb = m.groups()

1247

self.starta, self.lena, self.startb, self.lenb = m.groups()

1248

if self.lena is None:

1248

if self.lena is None:

1249

self.lena = 1

1249

self.lena = 1

1250

else:

1250

else:

1251

self.lena = int(self.lena)

1251

self.lena = int(self.lena)

1252

if self.lenb is None:

1252

if self.lenb is None:

1253

self.lenb = 1

1253

self.lenb = 1

1254

else:

1254

else:

1255

self.lenb = int(self.lenb)

1255

self.lenb = int(self.lenb)

1256

self.starta = int(self.starta)

1256

self.starta = int(self.starta)

1257

self.startb = int(self.startb)

1257

self.startb = int(self.startb)

1258

diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a,

1258

diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a,

1259

self.b)

1259

self.b)

1260

# if we hit eof before finishing out the hunk, the last line will

1260

# if we hit eof before finishing out the hunk, the last line will

1261

# be zero length. Lets try to fix it up.

1261

# be zero length. Lets try to fix it up.

1262

while len(self.hunk[-1]) == 0:

1262

while len(self.hunk[-1]) == 0:

1263

del self.hunk[-1]

1263

del self.hunk[-1]

1264

del self.a[-1]

1264

del self.a[-1]

1265

del self.b[-1]

1265

del self.b[-1]

1266

self.lena -= 1

1266

self.lena -= 1

1267

self.lenb -= 1

1267

self.lenb -= 1

1268

self._fixnewline(lr)

1268

self._fixnewline(lr)

1269

1270

def read_context_hunk(self, lr):

1270

def read_context_hunk(self, lr):

1271

self.desc = lr.readline()

1271

self.desc = lr.readline()

1272

m = contextdesc.match(self.desc)

1272

m = contextdesc.match(self.desc)

1273

if not m:

1273

if not m:

1274

raise PatchError(_("bad hunk #%d") % self.number)

1274

raise PatchError(_("bad hunk #%d") % self.number)

1275

self.starta, aend = m.groups()

1275

self.starta, aend = m.groups()

1276

self.starta = int(self.starta)

1276

self.starta = int(self.starta)

1277

if aend is None:

1277

if aend is None:

1278

aend = self.starta

1278

aend = self.starta

1279

self.lena = int(aend) - self.starta

1279

self.lena = int(aend) - self.starta

1280

if self.starta:

1280

if self.starta:

1281

self.lena += 1

1281

self.lena += 1

1282

for x in xrange(self.lena):

1282

for x in xrange(self.lena):

1283

l = lr.readline()

1283

l = lr.readline()

1284

if l.startswith('---'):

1284

if l.startswith('---'):

1285

# lines addition, old block is empty

1285

# lines addition, old block is empty

1286

lr.push(l)

1286

lr.push(l)

1287

break

1287

break

1288

s = l[2:]

1288

s = l[2:]

1289

if l.startswith('- ') or l.startswith('! '):

1289

if l.startswith('- ') or l.startswith('! '):

1290

u = '-' + s

1290

u = '-' + s

1291

elif l.startswith(' '):

1291

elif l.startswith(' '):

1292

u = ' ' + s

1292

u = ' ' + s

1293

else:

1293

else:

1294

raise PatchError(_("bad hunk #%d old text line %d") %

1294

raise PatchError(_("bad hunk #%d old text line %d") %

1295

(self.number, x))

1295

(self.number, x))

1296

self.a.append(u)

1296

self.a.append(u)

1297

self.hunk.append(u)

1297

self.hunk.append(u)

1298

1299

l = lr.readline()

1299

l = lr.readline()

1300

if l.startswith('\ '):

1300

if l.startswith('\ '):

1301

s = self.a[-1][:-1]

1301

s = self.a[-1][:-1]

1302

self.a[-1] = s

1302

self.a[-1] = s

1303

self.hunk[-1] = s

1303

self.hunk[-1] = s

1304

l = lr.readline()

1304

l = lr.readline()

1305

m = contextdesc.match(l)

1305

m = contextdesc.match(l)

1306

if not m:

1306

if not m:

1307

raise PatchError(_("bad hunk #%d") % self.number)

1307

raise PatchError(_("bad hunk #%d") % self.number)

1308

self.startb, bend = m.groups()

1308

self.startb, bend = m.groups()

1309

self.startb = int(self.startb)

1309

self.startb = int(self.startb)

1310

if bend is None:

1310

if bend is None:

1311

bend = self.startb

1311

bend = self.startb

1312

self.lenb = int(bend) - self.startb

1312

self.lenb = int(bend) - self.startb

1313

if self.startb:

1313

if self.startb:

1314

self.lenb += 1

1314

self.lenb += 1

1315

hunki = 1

1315

hunki = 1

1316

for x in xrange(self.lenb):

1316

for x in xrange(self.lenb):

1317

l = lr.readline()

1317

l = lr.readline()

1318

if l.startswith('\ '):

1318

if l.startswith('\ '):

1319

# XXX: the only way to hit this is with an invalid line range.

1319

# XXX: the only way to hit this is with an invalid line range.

1320

# The no-eol marker is not counted in the line range, but I

1320

# The no-eol marker is not counted in the line range, but I

1321

# guess there are diff(1) out there which behave differently.

1321

# guess there are diff(1) out there which behave differently.

1322

s = self.b[-1][:-1]

1322

s = self.b[-1][:-1]

1323

self.b[-1] = s

1323

self.b[-1] = s

1324

self.hunk[hunki - 1] = s

1324

self.hunk[hunki - 1] = s

1325

continue

1325

continue

1326

if not l:

1326

if not l:

1327

# line deletions, new block is empty and we hit EOF

1327

# line deletions, new block is empty and we hit EOF

1328

lr.push(l)

1328

lr.push(l)

1329

break

1329

break

1330

s = l[2:]

1330

s = l[2:]

1331

if l.startswith('+ ') or l.startswith('! '):

1331

if l.startswith('+ ') or l.startswith('! '):

1332

u = '+' + s

1332

u = '+' + s

1333

elif l.startswith(' '):

1333

elif l.startswith(' '):

1334

u = ' ' + s

1334

u = ' ' + s

1335

elif len(self.b) == 0:

1335

elif len(self.b) == 0:

1336

# line deletions, new block is empty

1336

# line deletions, new block is empty

1337

lr.push(l)

1337

lr.push(l)

1338

break

1338

break

1339

else:

1339

else:

1340

raise PatchError(_("bad hunk #%d old text line %d") %

1340

raise PatchError(_("bad hunk #%d old text line %d") %

1341

(self.number, x))

1341

(self.number, x))

1342

self.b.append(s)

1342

self.b.append(s)

1343

while True:

1343

while True:

1344

if hunki >= len(self.hunk):

1344

if hunki >= len(self.hunk):

1345

h = ""

1345

h = ""

1346

else:

1346

else:

1347

h = self.hunk[hunki]

1347

h = self.hunk[hunki]

1348

hunki += 1

1348

hunki += 1

1349

if h == u:

1349

if h == u:

1350

break

1350

break

1351

elif h.startswith('-'):

1351

elif h.startswith('-'):

1352

continue

1352

continue

1353

else:

1353

else:

1354

self.hunk.insert(hunki - 1, u)

1354

self.hunk.insert(hunki - 1, u)

1355

break

1355

break

1356

1357

if not self.a:

1357

if not self.a:

1358

# this happens when lines were only added to the hunk

1358

# this happens when lines were only added to the hunk

1359

for x in self.hunk:

1359

for x in self.hunk:

1360

if x.startswith('-') or x.startswith(' '):

1360

if x.startswith('-') or x.startswith(' '):

1361

self.a.append(x)

1361

self.a.append(x)

1362

if not self.b:

1362

if not self.b:

1363

# this happens when lines were only deleted from the hunk

1363

# this happens when lines were only deleted from the hunk

1364

for x in self.hunk:

1364

for x in self.hunk:

1365

if x.startswith('+') or x.startswith(' '):

1365

if x.startswith('+') or x.startswith(' '):

1366

self.b.append(x[1:])

1366

self.b.append(x[1:])

1367

# @@ -start,len +start,len @@

1367

# @@ -start,len +start,len @@

1368

self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,

1368

self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,

1369

self.startb, self.lenb)

1369

self.startb, self.lenb)

1370

self.hunk[0] = self.desc

1370

self.hunk[0] = self.desc

1371

self._fixnewline(lr)

1371

self._fixnewline(lr)

1372

1373

def _fixnewline(self, lr):

1373

def _fixnewline(self, lr):

1374

l = lr.readline()

1374

l = lr.readline()

1375

if l.startswith('\ '):

1375

if l.startswith('\ '):

1376

diffhelpers.fix_newline(self.hunk, self.a, self.b)

1376

diffhelpers.fix_newline(self.hunk, self.a, self.b)

1377

else:

1377

else:

1378

lr.push(l)

1378

lr.push(l)

1379

1380

def complete(self):

1380

def complete(self):

1381

return len(self.a) == self.lena and len(self.b) == self.lenb

1381

return len(self.a) == self.lena and len(self.b) == self.lenb

1382

1383

def _fuzzit(self, old, new, fuzz, toponly):

1383

def _fuzzit(self, old, new, fuzz, toponly):

1384

# this removes context lines from the top and bottom of list 'l'. It

1384

# this removes context lines from the top and bottom of list 'l'. It

1385

# checks the hunk to make sure only context lines are removed, and then

1385

# checks the hunk to make sure only context lines are removed, and then

1386

# returns a new shortened list of lines.

1386

# returns a new shortened list of lines.

1387

fuzz = min(fuzz, len(old))

1387

fuzz = min(fuzz, len(old))

1388

if fuzz:

1388

if fuzz:

1389

top = 0

1389

top = 0

1390

bot = 0

1390

bot = 0

1391

hlen = len(self.hunk)

1391

hlen = len(self.hunk)

1392

for x in xrange(hlen - 1):

1392

for x in xrange(hlen - 1):

1393

# the hunk starts with the @@ line, so use x+1

1393

# the hunk starts with the @@ line, so use x+1

1394

if self.hunk[x + 1][0] == ' ':

1394

if self.hunk[x + 1].startswith(' '):

1395

top += 1

1395

top += 1

1396

else:

1396

else:

1397

break

1397

break

1398

if not toponly:

1398

if not toponly:

1399

for x in xrange(hlen - 1):

1399

for x in xrange(hlen - 1):

1400

if self.hunk[hlen - bot - 1][0] == ' ':

1400

if self.hunk[hlen - bot - 1].startswith(' '):

1401

bot += 1

1401

bot += 1

1402

else:

1402

else:

1403

break

1403

break

1404

1405

bot = min(fuzz, bot)

1405

bot = min(fuzz, bot)

1406

top = min(fuzz, top)

1406

top = min(fuzz, top)

1407

return old[top:len(old) - bot], new[top:len(new) - bot], top

1407

return old[top:len(old) - bot], new[top:len(new) - bot], top

1408

return old, new, 0

1408

return old, new, 0

1409

1410

def fuzzit(self, fuzz, toponly):

1410

def fuzzit(self, fuzz, toponly):

1411

old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)

1411

old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)

1412

oldstart = self.starta + top

1412

oldstart = self.starta + top

1413

newstart = self.startb + top

1413

newstart = self.startb + top

1414

# zero length hunk ranges already have their start decremented

1414

# zero length hunk ranges already have their start decremented

1415

if self.lena and oldstart > 0:

1415

if self.lena and oldstart > 0:

1416

oldstart -= 1

1416

oldstart -= 1

1417

if self.lenb and newstart > 0:

1417

if self.lenb and newstart > 0:

1418

newstart -= 1

1418

newstart -= 1

1419

return old, oldstart, new, newstart

1419

return old, oldstart, new, newstart

1420

1421

class binhunk(object):

1421

class binhunk(object):

1422

'A binary patch file.'

1422

'A binary patch file.'

1423

def __init__(self, lr, fname):

1423

def __init__(self, lr, fname):

1424

self.text = None

1424

self.text = None

1425

self.delta = False

1425

self.delta = False

1426

self.hunk = ['GIT binary patch\n']

1426

self.hunk = ['GIT binary patch\n']

1427

self._fname = fname

1427

self._fname = fname

1428

self._read(lr)

1428

self._read(lr)

1429

1430

def complete(self):

1430

def complete(self):

1431

return self.text is not None

1431

return self.text is not None

1432

1433

def new(self, lines):

1433

def new(self, lines):

1434

if self.delta:

1434

if self.delta:

1435

return [applybindelta(self.text, ''.join(lines))]

1435

return [applybindelta(self.text, ''.join(lines))]

1436

return [self.text]

1436

return [self.text]

1437

1438

def _read(self, lr):

1438

def _read(self, lr):

1439

def getline(lr, hunk):

1439

def getline(lr, hunk):

1440

l = lr.readline()

1440

l = lr.readline()

1441

hunk.append(l)

1441

hunk.append(l)

1442

return l.rstrip('\r\n')

1442

return l.rstrip('\r\n')

1443

1444

size = 0

1444

size = 0

1445

while True:

1445

while True:

1446

line = getline(lr, self.hunk)

1446

line = getline(lr, self.hunk)

1447

if not line:

1447

if not line:

1448

raise PatchError(_('could not extract "%s" binary data')

1448

raise PatchError(_('could not extract "%s" binary data')

1449

% self._fname)

1449

% self._fname)

1450

if line.startswith('literal '):

1450

if line.startswith('literal '):

1451

size = int(line[8:].rstrip())

1451

size = int(line[8:].rstrip())

1452

break

1452

break

1453

if line.startswith('delta '):

1453

if line.startswith('delta '):

1454

size = int(line[6:].rstrip())

1454

size = int(line[6:].rstrip())

1455

self.delta = True

1455

self.delta = True

1456

break

1456

break

1457

dec = []

1457

dec = []

1458

line = getline(lr, self.hunk)

1458

line = getline(lr, self.hunk)

1459

while len(line) > 1:

1459

while len(line) > 1:

1460

l = line[0:1]

1460

l = line[0:1]

1461

if l <= 'Z' and l >= 'A':

1461

if l <= 'Z' and l >= 'A':

1462

l = ord(l) - ord('A') + 1

1462

l = ord(l) - ord('A') + 1

1463

else:

1463

else:

1464

l = ord(l) - ord('a') + 27

1464

l = ord(l) - ord('a') + 27

1465

try:

1465

try:

1466

dec.append(util.b85decode(line[1:])[:l])

1466

dec.append(util.b85decode(line[1:])[:l])

1467

except ValueError as e:

1467

except ValueError as e:

1468

raise PatchError(_('could not decode "%s" binary patch: %s')

1468

raise PatchError(_('could not decode "%s" binary patch: %s')

1469

% (self._fname, stringutil.forcebytestr(e)))

1469

% (self._fname, stringutil.forcebytestr(e)))

1470

line = getline(lr, self.hunk)

1470

line = getline(lr, self.hunk)

1471

text = zlib.decompress(''.join(dec))

1471

text = zlib.decompress(''.join(dec))

1472

if len(text) != size:

1472

if len(text) != size:

1473

raise PatchError(_('"%s" length is %d bytes, should be %d')

1473

raise PatchError(_('"%s" length is %d bytes, should be %d')

1474

% (self._fname, len(text), size))

1474

% (self._fname, len(text), size))

1475

self.text = text

1475

self.text = text

1476

1477

def parsefilename(str):

1477

def parsefilename(str):

1478

# --- filename \t|space stuff

1478

# --- filename \t|space stuff

1479

s = str[4:].rstrip('\r\n')

1479

s = str[4:].rstrip('\r\n')

1480

i = s.find('\t')

1480

i = s.find('\t')

1481

if i < 0:

1481

if i < 0:

1482

i = s.find(' ')

1482

i = s.find(' ')

1483

if i < 0:

1483

if i < 0:

1484

return s

1484

return s

1485

return s[:i]

1485

return s[:i]

1486

1487

def reversehunks(hunks):

1487

def reversehunks(hunks):

1488

'''reverse the signs in the hunks given as argument

1488

'''reverse the signs in the hunks given as argument

1489

1490

This function operates on hunks coming out of patch.filterpatch, that is

1490

This function operates on hunks coming out of patch.filterpatch, that is

1491

a list of the form: [header1, hunk1, hunk2, header2...]. Example usage:

1491

a list of the form: [header1, hunk1, hunk2, header2...]. Example usage:

1492

1493

>>> rawpatch = b"""diff --git a/folder1/g b/folder1/g

1493

>>> rawpatch = b"""diff --git a/folder1/g b/folder1/g

1494

... --- a/folder1/g

1494

... --- a/folder1/g

1495

... +++ b/folder1/g

1495

... +++ b/folder1/g

1496

... @@ -1,7 +1,7 @@

1496

... @@ -1,7 +1,7 @@

1497

... +firstline

1497

... +firstline

1498

... c

1498

... c

1499

... 1

1499

... 1

1500

... 2

1500

... 2

1501

... + 3

1501

... + 3

1502

... -4

1502

... -4

1503

... 5

1503

... 5

1504

... d

1504

... d

1505

... +lastline"""

1505

... +lastline"""

1506

>>> hunks = parsepatch([rawpatch])

1506

>>> hunks = parsepatch([rawpatch])

1507

>>> hunkscomingfromfilterpatch = []

1507

>>> hunkscomingfromfilterpatch = []

1508

>>> for h in hunks:

1508

>>> for h in hunks:

1509

... hunkscomingfromfilterpatch.append(h)

1509

... hunkscomingfromfilterpatch.append(h)

1510

... hunkscomingfromfilterpatch.extend(h.hunks)

1510

... hunkscomingfromfilterpatch.extend(h.hunks)

1511

1512

>>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)

1512

>>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)

1513

>>> from . import util

1513

>>> from . import util

1514

>>> fp = util.stringio()

1514

>>> fp = util.stringio()

1515

>>> for c in reversedhunks:

1515

>>> for c in reversedhunks:

1516

... c.write(fp)

1516

... c.write(fp)

1517

>>> fp.seek(0) or None

1517

>>> fp.seek(0) or None

1518

>>> reversedpatch = fp.read()

1518

>>> reversedpatch = fp.read()

1519

>>> print(pycompat.sysstr(reversedpatch))

1519

>>> print(pycompat.sysstr(reversedpatch))

1520

diff --git a/folder1/g b/folder1/g

1520

diff --git a/folder1/g b/folder1/g

1521

--- a/folder1/g

1521

--- a/folder1/g

1522

+++ b/folder1/g

1522

+++ b/folder1/g

1523

@@ -1,4 +1,3 @@

1523

@@ -1,4 +1,3 @@

1524

-firstline

1524

-firstline

1525

c

1525

c

1526

1

1526

1

1527

2

1527

2

1528

@@ -2,6 +1,6 @@

1528

@@ -2,6 +1,6 @@

1529

c

1529

c

1530

1

1530

1

1531

2

1531

2

1532

- 3

1532

- 3

1533

+4

1533

+4

1534

5

1534

5

1535

d

1535

d

1536

@@ -6,3 +5,2 @@

1536

@@ -6,3 +5,2 @@

1537

5

1537

5

1538

d

1538

d

1539

-lastline

1539

-lastline

1540

1541

'''

1541

'''

1542

1543

newhunks = []

1543

newhunks = []

1544

for c in hunks:

1544

for c in hunks:

1545

if util.safehasattr(c, 'reversehunk'):

1545

if util.safehasattr(c, 'reversehunk'):

1546

c = c.reversehunk()

1546

c = c.reversehunk()

1547

newhunks.append(c)

1547

newhunks.append(c)

1548

return newhunks

1548

return newhunks

1549

1550

def parsepatch(originalchunks, maxcontext=None):

1550

def parsepatch(originalchunks, maxcontext=None):

1551

"""patch -> [] of headers -> [] of hunks

1551

"""patch -> [] of headers -> [] of hunks

1552

1553

If maxcontext is not None, trim context lines if necessary.

1553

If maxcontext is not None, trim context lines if necessary.

1554

1555

>>> rawpatch = b'''diff --git a/folder1/g b/folder1/g

1555

>>> rawpatch = b'''diff --git a/folder1/g b/folder1/g

1556

... --- a/folder1/g

1556

... --- a/folder1/g

1557

... +++ b/folder1/g

1557

... +++ b/folder1/g

1558

... @@ -1,8 +1,10 @@

1558

... @@ -1,8 +1,10 @@

1559

... 1

1559

... 1

1560

... 2

1560

... 2

1561

... -3

1561

... -3

1562

... 4

1562

... 4

1563

... 5

1563

... 5

1564

... 6

1564

... 6

1565

... +6.1

1565

... +6.1

1566

... +6.2

1566

... +6.2

1567

... 7

1567

... 7

1568

... 8

1568

... 8

1569

... +9'''

1569

... +9'''

1570

>>> out = util.stringio()

1570

>>> out = util.stringio()

1571

>>> headers = parsepatch([rawpatch], maxcontext=1)

1571

>>> headers = parsepatch([rawpatch], maxcontext=1)

1572

>>> for header in headers:

1572

>>> for header in headers:

1573

... header.write(out)

1573

... header.write(out)

1574

... for hunk in header.hunks:

1574

... for hunk in header.hunks:

1575

... hunk.write(out)

1575

... hunk.write(out)

1576

>>> print(pycompat.sysstr(out.getvalue()))

1576

>>> print(pycompat.sysstr(out.getvalue()))

1577

diff --git a/folder1/g b/folder1/g

1577

diff --git a/folder1/g b/folder1/g

1578

--- a/folder1/g

1578

--- a/folder1/g

1579

+++ b/folder1/g

1579

+++ b/folder1/g

1580

@@ -2,3 +2,2 @@

1580

@@ -2,3 +2,2 @@

1581

2

1581

2

1582

-3

1582

-3

1583

4

1583

4

1584

@@ -6,2 +5,4 @@

1584

@@ -6,2 +5,4 @@

1585

6

1585

6

1586

+6.1

1586

+6.1

1587

+6.2

1587

+6.2

1588

7

1588

7

1589

@@ -8,1 +9,2 @@

1589

@@ -8,1 +9,2 @@

1590

8

1590

8

1591

+9

1591

+9

1592

"""

1592

"""

1593

class parser(object):

1593

class parser(object):

1594

"""patch parsing state machine"""

1594

"""patch parsing state machine"""

1595

def __init__(self):

1595

def __init__(self):

1596

self.fromline = 0

1596

self.fromline = 0

1597

self.toline = 0

1597

self.toline = 0

1598

self.proc = ''

1598

self.proc = ''

1599

self.header = None

1599

self.header = None

1600

self.context = []

1600

self.context = []

1601

self.before = []

1601

self.before = []

1602

self.hunk = []

1602

self.hunk = []

1603

self.headers = []

1603

self.headers = []

1604

1605

def addrange(self, limits):

1605

def addrange(self, limits):

1606

fromstart, fromend, tostart, toend, proc = limits

1606

fromstart, fromend, tostart, toend, proc = limits

1607

self.fromline = int(fromstart)

1607

self.fromline = int(fromstart)

1608

self.toline = int(tostart)

1608

self.toline = int(tostart)

1609

self.proc = proc

1609

self.proc = proc

1610

1611

def addcontext(self, context):

1611

def addcontext(self, context):

1612

if self.hunk:

1612

if self.hunk:

1613

h = recordhunk(self.header, self.fromline, self.toline,

1613

h = recordhunk(self.header, self.fromline, self.toline,

1614

self.proc, self.before, self.hunk, context, maxcontext)

1614

self.proc, self.before, self.hunk, context, maxcontext)

1615

self.header.hunks.append(h)

1615

self.header.hunks.append(h)

1616

self.fromline += len(self.before) + h.removed

1616

self.fromline += len(self.before) + h.removed

1617

self.toline += len(self.before) + h.added

1617

self.toline += len(self.before) + h.added

1618

self.before = []

1618

self.before = []

1619

self.hunk = []

1619

self.hunk = []

1620

self.context = context

1620

self.context = context

1621

1622

def addhunk(self, hunk):

1622

def addhunk(self, hunk):

1623

if self.context:

1623

if self.context:

1624

self.before = self.context

1624

self.before = self.context

1625

self.context = []

1625

self.context = []

1626

self.hunk = hunk

1626

self.hunk = hunk

1627

1628

def newfile(self, hdr):

1628

def newfile(self, hdr):

1629

self.addcontext([])

1629

self.addcontext([])

1630

h = header(hdr)

1630

h = header(hdr)

1631

self.headers.append(h)

1631

self.headers.append(h)

1632

self.header = h

1632

self.header = h

1633

1634

def addother(self, line):

1634

def addother(self, line):

1635

pass # 'other' lines are ignored

1635

pass # 'other' lines are ignored

1636

1637

def finished(self):

1637

def finished(self):

1638

self.addcontext([])

1638

self.addcontext([])

1639

return self.headers

1639

return self.headers

1640

1641

transitions = {

1641

transitions = {

1642

'file': {'context': addcontext,

1642

'file': {'context': addcontext,

1643

'file': newfile,

1643

'file': newfile,

1644

'hunk': addhunk,

1644

'hunk': addhunk,

1645

'range': addrange},

1645

'range': addrange},

1646

'context': {'file': newfile,

1646

'context': {'file': newfile,

1647

'hunk': addhunk,

1647

'hunk': addhunk,

1648

'range': addrange,

1648

'range': addrange,

1649

'other': addother},

1649

'other': addother},

1650

'hunk': {'context': addcontext,

1650

'hunk': {'context': addcontext,

1651

'file': newfile,

1651

'file': newfile,

1652

'range': addrange},

1652

'range': addrange},

1653

'range': {'context': addcontext,

1653

'range': {'context': addcontext,

1654

'hunk': addhunk},

1654

'hunk': addhunk},

1655

'other': {'other': addother},

1655

'other': {'other': addother},

1656

}

1656

}

1657

1658

p = parser()

1658

p = parser()

1659

fp = stringio()

1659

fp = stringio()

1660

fp.write(''.join(originalchunks))

1660

fp.write(''.join(originalchunks))

1661

fp.seek(0)

1661

fp.seek(0)

1662

1663

state = 'context'

1663

state = 'context'

1664

for newstate, data in scanpatch(fp):

1664

for newstate, data in scanpatch(fp):

1665

try:

1665

try:

1666

p.transitions[state][newstate](p, data)

1666

p.transitions[state][newstate](p, data)

1667

except KeyError:

1667

except KeyError:

1668

raise PatchError('unhandled transition: %s -> %s' %

1668

raise PatchError('unhandled transition: %s -> %s' %

1669

(state, newstate))

1669

(state, newstate))

1670

state = newstate

1670

state = newstate

1671

del fp

1671

del fp

1672

return p.finished()

1672

return p.finished()

1673

1674

def pathtransform(path, strip, prefix):

1674

def pathtransform(path, strip, prefix):

1675

'''turn a path from a patch into a path suitable for the repository

1675

'''turn a path from a patch into a path suitable for the repository

1676

1677

prefix, if not empty, is expected to be normalized with a / at the end.

1677

prefix, if not empty, is expected to be normalized with a / at the end.

1678

1679

Returns (stripped components, path in repository).

1679

Returns (stripped components, path in repository).

1680

1681

>>> pathtransform(b'a/b/c', 0, b'')

1681

>>> pathtransform(b'a/b/c', 0, b'')

1682

('', 'a/b/c')

1682

('', 'a/b/c')

1683

>>> pathtransform(b' a/b/c ', 0, b'')

1683

>>> pathtransform(b' a/b/c ', 0, b'')

1684

('', ' a/b/c')

1684

('', ' a/b/c')

1685

>>> pathtransform(b' a/b/c ', 2, b'')

1685

>>> pathtransform(b' a/b/c ', 2, b'')

1686

('a/b/', 'c')

1686

('a/b/', 'c')

1687

>>> pathtransform(b'a/b/c', 0, b'd/e/')

1687

>>> pathtransform(b'a/b/c', 0, b'd/e/')

1688

('', 'd/e/a/b/c')

1688

('', 'd/e/a/b/c')

1689

>>> pathtransform(b' a//b/c ', 2, b'd/e/')

1689

>>> pathtransform(b' a//b/c ', 2, b'd/e/')

1690

('a//b/', 'd/e/c')

1690

('a//b/', 'd/e/c')

1691

>>> pathtransform(b'a/b/c', 3, b'')

1691

>>> pathtransform(b'a/b/c', 3, b'')

1692

Traceback (most recent call last):

1692

Traceback (most recent call last):

1693

PatchError: unable to strip away 1 of 3 dirs from a/b/c

1693

PatchError: unable to strip away 1 of 3 dirs from a/b/c

1694

'''

1694

'''

1695

pathlen = len(path)

1695

pathlen = len(path)

1696

i = 0

1696

i = 0

1697

if strip == 0:

1697

if strip == 0:

1698

return '', prefix + path.rstrip()

1698

return '', prefix + path.rstrip()

1699

count = strip

1699

count = strip

1700

while count > 0:

1700

while count > 0:

1701

i = path.find('/', i)

1701

i = path.find('/', i)

1702

if i == -1:

1702

if i == -1:

1703

raise PatchError(_("unable to strip away %d of %d dirs from %s") %

1703

raise PatchError(_("unable to strip away %d of %d dirs from %s") %

1704

(count, strip, path))

1704

(count, strip, path))

1705

i += 1

1705

i += 1

1706

# consume '//' in the path

1706

# consume '//' in the path

1707

while i < pathlen - 1 and path[i:i + 1] == '/':

1707

while i < pathlen - 1 and path[i:i + 1] == '/':

1708

i += 1

1708

i += 1

1709

count -= 1

1709

count -= 1

1710

return path[:i].lstrip(), prefix + path[i:].rstrip()

1710

return path[:i].lstrip(), prefix + path[i:].rstrip()

1711

1712

def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):

1712

def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):

1713

nulla = afile_orig == "/dev/null"

1713

nulla = afile_orig == "/dev/null"

1714

nullb = bfile_orig == "/dev/null"

1714

nullb = bfile_orig == "/dev/null"

1715

create = nulla and hunk.starta == 0 and hunk.lena == 0

1715

create = nulla and hunk.starta == 0 and hunk.lena == 0

1716

remove = nullb and hunk.startb == 0 and hunk.lenb == 0

1716

remove = nullb and hunk.startb == 0 and hunk.lenb == 0

1717

abase, afile = pathtransform(afile_orig, strip, prefix)

1717

abase, afile = pathtransform(afile_orig, strip, prefix)

1718

gooda = not nulla and backend.exists(afile)

1718

gooda = not nulla and backend.exists(afile)

1719

bbase, bfile = pathtransform(bfile_orig, strip, prefix)

1719

bbase, bfile = pathtransform(bfile_orig, strip, prefix)

1720

if afile == bfile:

1720

if afile == bfile:

1721

goodb = gooda

1721

goodb = gooda

1722

else:

1722

else:

1723

goodb = not nullb and backend.exists(bfile)

1723

goodb = not nullb and backend.exists(bfile)

1724

missing = not goodb and not gooda and not create

1724

missing = not goodb and not gooda and not create

1725

1726

# some diff programs apparently produce patches where the afile is

1726

# some diff programs apparently produce patches where the afile is

1727

# not /dev/null, but afile starts with bfile

1727

# not /dev/null, but afile starts with bfile

1728

abasedir = afile[:afile.rfind('/') + 1]

1728

abasedir = afile[:afile.rfind('/') + 1]

1729

bbasedir = bfile[:bfile.rfind('/') + 1]

1729

bbasedir = bfile[:bfile.rfind('/') + 1]

1730

if (missing and abasedir == bbasedir and afile.startswith(bfile)

1730

if (missing and abasedir == bbasedir and afile.startswith(bfile)

1731

and hunk.starta == 0 and hunk.lena == 0):

1731

and hunk.starta == 0 and hunk.lena == 0):

1732

create = True

1732

create = True

1733

missing = False

1733

missing = False

1734

1735

# If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the

1735

# If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the

1736

# diff is between a file and its backup. In this case, the original

1736

# diff is between a file and its backup. In this case, the original

1737

# file should be patched (see original mpatch code).

1737

# file should be patched (see original mpatch code).

1738

isbackup = (abase == bbase and bfile.startswith(afile))

1738

isbackup = (abase == bbase and bfile.startswith(afile))

1739

fname = None

1739

fname = None

1740

if not missing:

1740

if not missing:

1741

if gooda and goodb:

1741

if gooda and goodb:

1742

if isbackup:

1742

if isbackup:

1743

fname = afile

1743

fname = afile

1744

else:

1744

else:

1745

fname = bfile

1745

fname = bfile

1746

elif gooda:

1746

elif gooda:

1747

fname = afile

1747

fname = afile

1748

1749

if not fname:

1749

if not fname:

1750

if not nullb:

1750

if not nullb:

1751

if isbackup:

1751

if isbackup:

1752

fname = afile

1752

fname = afile

1753

else:

1753

else:

1754

fname = bfile

1754

fname = bfile

1755

elif not nulla:

1755

elif not nulla:

1756

fname = afile

1756

fname = afile

1757

else:

1757

else:

1758

raise PatchError(_("undefined source and destination files"))

1758

raise PatchError(_("undefined source and destination files"))

1759

1760

gp = patchmeta(fname)

1760

gp = patchmeta(fname)

1761

if create:

1761

if create:

1762

gp.op = 'ADD'

1762

gp.op = 'ADD'

1763

elif remove:

1763

elif remove:

1764

gp.op = 'DELETE'

1764

gp.op = 'DELETE'

1765

return gp

1765

return gp

1766

1767

def scanpatch(fp):

1767

def scanpatch(fp):

1768

"""like patch.iterhunks, but yield different events

1768

"""like patch.iterhunks, but yield different events

1769

1770

- ('file', [header_lines + fromfile + tofile])

1770

- ('file', [header_lines + fromfile + tofile])

1771

- ('context', [context_lines])

1771

- ('context', [context_lines])

1772

- ('hunk', [hunk_lines])

1772

- ('hunk', [hunk_lines])

1773

- ('range', (-start,len, +start,len, proc))

1773

- ('range', (-start,len, +start,len, proc))

1774

"""

1774

"""

1775

lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')

1775

lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')

1776

lr = linereader(fp)

1776

lr = linereader(fp)

1777

1778

def scanwhile(first, p):

1778

def scanwhile(first, p):

1779

"""scan lr while predicate holds"""

1779

"""scan lr while predicate holds"""

1780

lines = [first]

1780

lines = [first]

1781

for line in iter(lr.readline, ''):

1781

for line in iter(lr.readline, ''):

1782

if p(line):

1782

if p(line):

1783

lines.append(line)

1783

lines.append(line)

1784

else:

1784

else:

1785

lr.push(line)

1785

lr.push(line)

1786

break

1786

break

1787

return lines

1787

return lines

1788

1789

for line in iter(lr.readline, ''):

1789

for line in iter(lr.readline, ''):

1790

if line.startswith('diff --git a/') or line.startswith('diff -r '):

1790

if line.startswith('diff --git a/') or line.startswith('diff -r '):

1791

def notheader(line):

1791

def notheader(line):

1792

s = line.split(None, 1)

1792

s = line.split(None, 1)

1793

return not s or s[0] not in ('---', 'diff')

1793

return not s or s[0] not in ('---', 'diff')

1794

header = scanwhile(line, notheader)

1794

header = scanwhile(line, notheader)

1795

fromfile = lr.readline()

1795

fromfile = lr.readline()

1796

if fromfile.startswith('---'):

1796

if fromfile.startswith('---'):

1797

tofile = lr.readline()

1797

tofile = lr.readline()

1798

header += [fromfile, tofile]

1798

header += [fromfile, tofile]

1799

else:

1799

else:

1800

lr.push(fromfile)

1800

lr.push(fromfile)

1801

yield 'file', header

1801

yield 'file', header

1802

elif line[0:1] == ' ':

1802

elif line.startswith(' '):

1803

yield 'context', scanwhile(line, lambda l: l[0] in ' \\')

1803

cs = (' ', '\\')

1804

elif line[0] in '-+':

1804

yield 'context', scanwhile(line, lambda l: l.startswith(cs))

1805

yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\')

1805

elif line.startswith(('-', '+')):

1806

cs = ('-', '+', '\\')

1807

yield 'hunk', scanwhile(line, lambda l: l.startswith(cs))

1806

else:

1808

else:

1807

m = lines_re.match(line)

1809

m = lines_re.match(line)

1808

if m:

1810

if m:

1809

yield 'range', m.groups()

1811

yield 'range', m.groups()

1810

else:

1812

else:

1811

yield 'other', line

1813

yield 'other', line

1812

1814

1813

def scangitpatch(lr, firstline):

1815

def scangitpatch(lr, firstline):

1814

"""

1816

"""

1815

Git patches can emit:

1817

Git patches can emit:

1816

- rename a to b

1818

- rename a to b

1817

- change b

1819

- change b

1818

- copy a to c

1820

- copy a to c

1819

- change c

1821

- change c

1820

1822

1821

We cannot apply this sequence as-is, the renamed 'a' could not be

1823

We cannot apply this sequence as-is, the renamed 'a' could not be

1822

found for it would have been renamed already. And we cannot copy

1824

found for it would have been renamed already. And we cannot copy

1823

from 'b' instead because 'b' would have been changed already. So

1825

from 'b' instead because 'b' would have been changed already. So

1824

we scan the git patch for copy and rename commands so we can

1826

we scan the git patch for copy and rename commands so we can

1825

perform the copies ahead of time.

1827

perform the copies ahead of time.

1826

"""

1828

"""

1827

pos = 0

1829

pos = 0

1828

try:

1830

try:

1829

pos = lr.fp.tell()

1831

pos = lr.fp.tell()

1830

fp = lr.fp

1832

fp = lr.fp

1831

except IOError:

1833

except IOError:

1832

fp = stringio(lr.fp.read())

1834

fp = stringio(lr.fp.read())

1833

gitlr = linereader(fp)

1835

gitlr = linereader(fp)

1834

gitlr.push(firstline)

1836

gitlr.push(firstline)

1835

gitpatches = readgitpatch(gitlr)

1837

gitpatches = readgitpatch(gitlr)

1836

fp.seek(pos)

1838

fp.seek(pos)

1837

return gitpatches

1839

return gitpatches

1838

1840

1839

def iterhunks(fp):

1841

def iterhunks(fp):

1840

"""Read a patch and yield the following events:

1842

"""Read a patch and yield the following events:

1841

- ("file", afile, bfile, firsthunk): select a new target file.

1843

- ("file", afile, bfile, firsthunk): select a new target file.

1842

- ("hunk", hunk): a new hunk is ready to be applied, follows a

1844

- ("hunk", hunk): a new hunk is ready to be applied, follows a

1843

"file" event.

1845

"file" event.

1844

- ("git", gitchanges): current diff is in git format, gitchanges

1846

- ("git", gitchanges): current diff is in git format, gitchanges

1845

maps filenames to gitpatch records. Unique event.

1847

maps filenames to gitpatch records. Unique event.

1846

"""

1848

"""

1847

afile = ""

1849

afile = ""

1848

bfile = ""

1850

bfile = ""

1849

state = None

1851

state = None

1850

hunknum = 0

1852

hunknum = 0

1851

emitfile = newfile = False

1853

emitfile = newfile = False

1852

gitpatches = None

1854

gitpatches = None

1853

1855

1854

# our states

1856

# our states

1855

BFILE = 1

1857

BFILE = 1

1856

context = None

1858

context = None

1857

lr = linereader(fp)

1859

lr = linereader(fp)

1858

1860

1859

for x in iter(lr.readline, ''):

1861

for x in iter(lr.readline, ''):

1860

if state == BFILE and (

1862

if state == BFILE and (

1861

(not context and x.startswith('@'))

1863

(not context and x.startswith('@'))

1862

or (context is not False and x.startswith('***************'))

1864

or (context is not False and x.startswith('***************'))

1863

or x.startswith('GIT binary patch')):

1865

or x.startswith('GIT binary patch')):

1864

gp = None

1866

gp = None

1865

if (gitpatches and

1867

if (gitpatches and

1866

gitpatches[-1].ispatching(afile, bfile)):

1868

gitpatches[-1].ispatching(afile, bfile)):

1867

gp = gitpatches.pop()

1869

gp = gitpatches.pop()

1868

if x.startswith('GIT binary patch'):

1870

if x.startswith('GIT binary patch'):

1869

h = binhunk(lr, gp.path)

1871

h = binhunk(lr, gp.path)

1870

else:

1872

else:

1871

if context is None and x.startswith('***************'):

1873

if context is None and x.startswith('***************'):

1872

context = True

1874

context = True

1873

h = hunk(x, hunknum + 1, lr, context)

1875

h = hunk(x, hunknum + 1, lr, context)

1874

hunknum += 1

1876

hunknum += 1

1875

if emitfile:

1877

if emitfile:

1876

emitfile = False

1878

emitfile = False

1877

yield 'file', (afile, bfile, h, gp and gp.copy() or None)

1879

yield 'file', (afile, bfile, h, gp and gp.copy() or None)

1878

yield 'hunk', h

1880

yield 'hunk', h

1879

elif x.startswith('diff --git a/'):

1881

elif x.startswith('diff --git a/'):

1880

m = gitre.match(x.rstrip(' \r\n'))

1882

m = gitre.match(x.rstrip(' \r\n'))

1881

if not m:

1883

if not m:

1882

continue

1884

continue

1883

if gitpatches is None:

1885

if gitpatches is None:

1884

# scan whole input for git metadata

1886

# scan whole input for git metadata

1885

gitpatches = scangitpatch(lr, x)

1887

gitpatches = scangitpatch(lr, x)

1886

yield 'git', [g.copy() for g in gitpatches

1888

yield 'git', [g.copy() for g in gitpatches

1887

if g.op in ('COPY', 'RENAME')]

1889

if g.op in ('COPY', 'RENAME')]

1888

gitpatches.reverse()

1890

gitpatches.reverse()

1889

afile = 'a/' + m.group(1)

1891

afile = 'a/' + m.group(1)

1890

bfile = 'b/' + m.group(2)

1892

bfile = 'b/' + m.group(2)

1891

while gitpatches and not gitpatches[-1].ispatching(afile, bfile):

1893

while gitpatches and not gitpatches[-1].ispatching(afile, bfile):

1892

gp = gitpatches.pop()

1894

gp = gitpatches.pop()

1893

yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())

1895

yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())

1894

if not gitpatches:

1896

if not gitpatches:

1895

raise PatchError(_('failed to synchronize metadata for "%s"')

1897

raise PatchError(_('failed to synchronize metadata for "%s"')

1896

% afile[2:])

1898

% afile[2:])

1897

gp = gitpatches[-1]

1899

gp = gitpatches[-1]

1898

newfile = True

1900

newfile = True

1899

elif x.startswith('---'):

1901

elif x.startswith('---'):

1900

# check for a unified diff

1902

# check for a unified diff

1901

l2 = lr.readline()

1903

l2 = lr.readline()

1902

if not l2.startswith('+++'):

1904

if not l2.startswith('+++'):

1903

lr.push(l2)

1905

lr.push(l2)

1904

continue

1906

continue

1905

newfile = True

1907

newfile = True

1906

context = False

1908

context = False

1907

afile = parsefilename(x)

1909

afile = parsefilename(x)

1908

bfile = parsefilename(l2)

1910

bfile = parsefilename(l2)

1909

elif x.startswith('***'):

1911

elif x.startswith('***'):

1910

# check for a context diff

1912

# check for a context diff

1911

l2 = lr.readline()

1913

l2 = lr.readline()

1912

if not l2.startswith('---'):

1914

if not l2.startswith('---'):

1913

lr.push(l2)

1915

lr.push(l2)

1914

continue

1916

continue

1915

l3 = lr.readline()

1917

l3 = lr.readline()

1916

lr.push(l3)

1918

lr.push(l3)

1917

if not l3.startswith("***************"):

1919

if not l3.startswith("***************"):

1918

lr.push(l2)

1920

lr.push(l2)

1919

continue

1921

continue

1920

newfile = True

1922

newfile = True

1921

context = True

1923

context = True

1922

afile = parsefilename(x)

1924

afile = parsefilename(x)

1923

bfile = parsefilename(l2)

1925

bfile = parsefilename(l2)

1924

1926

1925

if newfile:

1927

if newfile:

1926

newfile = False

1928

newfile = False

1927

emitfile = True

1929

emitfile = True

1928

state = BFILE

1930

state = BFILE

1929

hunknum = 0

1931

hunknum = 0

1930

1932

1931

while gitpatches:

1933

while gitpatches:

1932

gp = gitpatches.pop()

1934

gp = gitpatches.pop()

1933

yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())

1935

yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())

1934

1936

1935

def applybindelta(binchunk, data):

1937

def applybindelta(binchunk, data):

1936

"""Apply a binary delta hunk

1938

"""Apply a binary delta hunk

1937

The algorithm used is the algorithm from git's patch-delta.c

1939

The algorithm used is the algorithm from git's patch-delta.c

1938

"""

1940

"""

1939

def deltahead(binchunk):

1941

def deltahead(binchunk):

1940

i = 0

1942

i = 0

1941

for c in binchunk:

1943

for c in binchunk:

1942

i += 1

1944

i += 1

1943

if not (ord(c) & 0x80):

1945

if not (ord(c) & 0x80):

1944

return i

1946

return i

1945

return i

1947

return i

1946

out = ""

1948

out = ""

1947

s = deltahead(binchunk)

1949

s = deltahead(binchunk)

1948

binchunk = binchunk[s:]

1950

binchunk = binchunk[s:]

1949

s = deltahead(binchunk)

1951

s = deltahead(binchunk)

1950

binchunk = binchunk[s:]

1952

binchunk = binchunk[s:]

1951

i = 0

1953

i = 0

1952

while i < len(binchunk):

1954

while i < len(binchunk):

1953

cmd = ord(binchunk[i])

1955

cmd = ord(binchunk[i])

1954

i += 1

1956

i += 1

1955

if (cmd & 0x80):

1957

if (cmd & 0x80):

1956

offset = 0

1958

offset = 0

1957

size = 0

1959

size = 0

1958

if (cmd & 0x01):

1960

if (cmd & 0x01):

1959

offset = ord(binchunk[i])

1961

offset = ord(binchunk[i])

1960

i += 1

1962

i += 1

1961

if (cmd & 0x02):

1963

if (cmd & 0x02):

1962

offset |= ord(binchunk[i]) << 8

1964

offset |= ord(binchunk[i]) << 8

1963

i += 1

1965

i += 1

1964

if (cmd & 0x04):

1966

if (cmd & 0x04):

1965

offset |= ord(binchunk[i]) << 16

1967

offset |= ord(binchunk[i]) << 16

1966

i += 1

1968

i += 1

1967

if (cmd & 0x08):

1969

if (cmd & 0x08):

1968

offset |= ord(binchunk[i]) << 24

1970

offset |= ord(binchunk[i]) << 24

1969

i += 1

1971

i += 1

1970

if (cmd & 0x10):

1972

if (cmd & 0x10):

1971

size = ord(binchunk[i])

1973

size = ord(binchunk[i])

1972

i += 1

1974

i += 1

1973

if (cmd & 0x20):

1975

if (cmd & 0x20):

1974

size |= ord(binchunk[i]) << 8

1976

size |= ord(binchunk[i]) << 8

1975

i += 1

1977

i += 1

1976

if (cmd & 0x40):

1978

if (cmd & 0x40):

1977

size |= ord(binchunk[i]) << 16

1979

size |= ord(binchunk[i]) << 16

1978

i += 1

1980

i += 1

1979

if size == 0:

1981

if size == 0:

1980

size = 0x10000

1982

size = 0x10000

1981

offset_end = offset + size

1983

offset_end = offset + size

1982

out += data[offset:offset_end]

1984

out += data[offset:offset_end]

1983

elif cmd != 0:

1985

elif cmd != 0:

1984

offset_end = i + cmd

1986

offset_end = i + cmd

1985

out += binchunk[i:offset_end]

1987

out += binchunk[i:offset_end]

1986

i += cmd

1988

i += cmd

1987

else:

1989

else:

1988

raise PatchError(_('unexpected delta opcode 0'))

1990

raise PatchError(_('unexpected delta opcode 0'))

1989

return out

1991

return out

1990

1992

1991

def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'):

1993

def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'):

1992

"""Reads a patch from fp and tries to apply it.

1994

"""Reads a patch from fp and tries to apply it.

1993

1995

1994

Returns 0 for a clean patch, -1 if any rejects were found and 1 if

1996

Returns 0 for a clean patch, -1 if any rejects were found and 1 if

1995

there was any fuzz.

1997

there was any fuzz.

1996

1998

1997

If 'eolmode' is 'strict', the patch content and patched file are

1999

If 'eolmode' is 'strict', the patch content and patched file are

1998

read in binary mode. Otherwise, line endings are ignored when

2000

read in binary mode. Otherwise, line endings are ignored when

1999

patching then normalized according to 'eolmode'.

2001

patching then normalized according to 'eolmode'.

2000

"""

2002

"""

2001

return _applydiff(ui, fp, patchfile, backend, store, strip=strip,

2003

return _applydiff(ui, fp, patchfile, backend, store, strip=strip,

2002

prefix=prefix, eolmode=eolmode)

2004

prefix=prefix, eolmode=eolmode)

2003

2005

2004

def _canonprefix(repo, prefix):

2006

def _canonprefix(repo, prefix):

2005

if prefix:

2007

if prefix:

2006

prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix)

2008

prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix)

2007

if prefix != '':

2009

if prefix != '':

2008

prefix += '/'

2010

prefix += '/'

2009

return prefix

2011

return prefix

2010

2012

2011

def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='',

2013

def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='',

2012

eolmode='strict'):

2014

eolmode='strict'):

2013

prefix = _canonprefix(backend.repo, prefix)

2015

prefix = _canonprefix(backend.repo, prefix)

2014

def pstrip(p):

2016

def pstrip(p):

2015

return pathtransform(p, strip - 1, prefix)[1]

2017

return pathtransform(p, strip - 1, prefix)[1]

2016

2018

2017

rejects = 0

2019

rejects = 0

2018

err = 0

2020

err = 0

2019

current_file = None

2021

current_file = None

2020

2022

2021

for state, values in iterhunks(fp):

2023

for state, values in iterhunks(fp):

2022

if state == 'hunk':

2024

if state == 'hunk':

2023

if not current_file:

2025

if not current_file:

2024

continue

2026

continue

2025

ret = current_file.apply(values)

2027

ret = current_file.apply(values)

2026

if ret > 0:

2028

if ret > 0:

2027

err = 1

2029

err = 1

2028

elif state == 'file':

2030

elif state == 'file':

2029

if current_file:

2031

if current_file:

2030

rejects += current_file.close()

2032

rejects += current_file.close()

2031

current_file = None

2033

current_file = None

2032

afile, bfile, first_hunk, gp = values

2034

afile, bfile, first_hunk, gp = values

2033

if gp:

2035

if gp:

2034

gp.path = pstrip(gp.path)

2036

gp.path = pstrip(gp.path)

2035

if gp.oldpath:

2037

if gp.oldpath:

2036

gp.oldpath = pstrip(gp.oldpath)

2038

gp.oldpath = pstrip(gp.oldpath)

2037

else:

2039

else:

2038

gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,

2040

gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,

2039

prefix)

2041

prefix)

2040

if gp.op == 'RENAME':

2042

if gp.op == 'RENAME':

2041

backend.unlink(gp.oldpath)

2043

backend.unlink(gp.oldpath)

2042

if not first_hunk:

2044

if not first_hunk:

2043

if gp.op == 'DELETE':

2045

if gp.op == 'DELETE':

2044

backend.unlink(gp.path)

2046

backend.unlink(gp.path)

2045

continue

2047

continue

2046

data, mode = None, None

2048

data, mode = None, None

2047

if gp.op in ('RENAME', 'COPY'):

2049

if gp.op in ('RENAME', 'COPY'):

2048

data, mode = store.getfile(gp.oldpath)[:2]

2050

data, mode = store.getfile(gp.oldpath)[:2]

2049

if data is None:

2051

if data is None:

2050

# This means that the old path does not exist

2052

# This means that the old path does not exist

2051

raise PatchError(_("source file '%s' does not exist")

2053

raise PatchError(_("source file '%s' does not exist")

2052

% gp.oldpath)

2054

% gp.oldpath)

2053

if gp.mode:

2055

if gp.mode:

2054

mode = gp.mode

2056

mode = gp.mode

2055

if gp.op == 'ADD':

2057

if gp.op == 'ADD':

2056

# Added files without content have no hunk and

2058

# Added files without content have no hunk and

2057

# must be created

2059

# must be created

2058

data = ''

2060

data = ''

2059

if data or mode:

2061

if data or mode:

2060

if (gp.op in ('ADD', 'RENAME', 'COPY')

2062

if (gp.op in ('ADD', 'RENAME', 'COPY')

2061

and backend.exists(gp.path)):

2063

and backend.exists(gp.path)):

2062

raise PatchError(_("cannot create %s: destination "

2064

raise PatchError(_("cannot create %s: destination "

2063

"already exists") % gp.path)

2065

"already exists") % gp.path)

2064

backend.setfile(gp.path, data, mode, gp.oldpath)

2066

backend.setfile(gp.path, data, mode, gp.oldpath)

2065

continue

2067

continue

2066

try:

2068

try:

2067

current_file = patcher(ui, gp, backend, store,

2069

current_file = patcher(ui, gp, backend, store,

2068

eolmode=eolmode)

2070

eolmode=eolmode)

2069

except PatchError as inst:

2071

except PatchError as inst:

2070

ui.warn(str(inst) + '\n')

2072

ui.warn(str(inst) + '\n')

2071

current_file = None

2073

current_file = None

2072

rejects += 1

2074

rejects += 1

2073

continue

2075

continue

2074

elif state == 'git':

2076

elif state == 'git':

2075

for gp in values:

2077

for gp in values:

2076

path = pstrip(gp.oldpath)

2078

path = pstrip(gp.oldpath)

2077

data, mode = backend.getfile(path)

2079

data, mode = backend.getfile(path)

2078

if data is None:

2080

if data is None:

2079

# The error ignored here will trigger a getfile()

2081

# The error ignored here will trigger a getfile()

2080

# error in a place more appropriate for error

2082

# error in a place more appropriate for error

2081

# handling, and will not interrupt the patching

2083

# handling, and will not interrupt the patching

2082

# process.

2084

# process.

2083

pass

2085

pass

2084

else:

2086

else:

2085

store.setfile(path, data, mode)

2087

store.setfile(path, data, mode)

2086

else:

2088

else:

2087

raise error.Abort(_('unsupported parser state: %s') % state)

2089

raise error.Abort(_('unsupported parser state: %s') % state)

2088

2090

2089

if current_file:

2091

if current_file:

2090

rejects += current_file.close()

2092

rejects += current_file.close()

2091

2093

2092

if rejects:

2094

if rejects:

2093

return -1

2095

return -1

2094

return err

2096

return err

2095

2097

2096

def _externalpatch(ui, repo, patcher, patchname, strip, files,

2098

def _externalpatch(ui, repo, patcher, patchname, strip, files,

2097

similarity):

2099

similarity):

2098

"""use <patcher> to apply <patchname> to the working directory.

2100

"""use <patcher> to apply <patchname> to the working directory.

2099

returns whether patch was applied with fuzz factor."""

2101

returns whether patch was applied with fuzz factor."""

2100

2102

2101

fuzz = False

2103

fuzz = False

2102

args = []

2104

args = []

2103

cwd = repo.root

2105

cwd = repo.root

2104

if cwd:

2106

if cwd:

2105

args.append('-d %s' % procutil.shellquote(cwd))

2107

args.append('-d %s' % procutil.shellquote(cwd))

2106

cmd = ('%s %s -p%d < %s'

2108

cmd = ('%s %s -p%d < %s'

2107

% (patcher, ' '.join(args), strip, procutil.shellquote(patchname)))

2109

% (patcher, ' '.join(args), strip, procutil.shellquote(patchname)))

2108

fp = procutil.popen(cmd, 'rb')

2110

fp = procutil.popen(cmd, 'rb')

2109

try:

2111

try:

2110

for line in util.iterfile(fp):

2112

for line in util.iterfile(fp):

2111

line = line.rstrip()

2113

line = line.rstrip()

2112

ui.note(line + '\n')

2114

ui.note(line + '\n')

2113

if line.startswith('patching file '):

2115

if line.startswith('patching file '):

2114

pf = util.parsepatchoutput(line)

2116

pf = util.parsepatchoutput(line)

2115

printed_file = False

2117

printed_file = False

2116

files.add(pf)

2118

files.add(pf)

2117

elif line.find('with fuzz') >= 0:

2119

elif line.find('with fuzz') >= 0:

2118

fuzz = True

2120

fuzz = True

2119

if not printed_file:

2121

if not printed_file:

2120

ui.warn(pf + '\n')

2122

ui.warn(pf + '\n')

2121

printed_file = True

2123

printed_file = True

2122

ui.warn(line + '\n')

2124

ui.warn(line + '\n')

2123

elif line.find('saving rejects to file') >= 0:

2125

elif line.find('saving rejects to file') >= 0:

2124

ui.warn(line + '\n')

2126

ui.warn(line + '\n')

2125

elif line.find('FAILED') >= 0:

2127

elif line.find('FAILED') >= 0:

2126

if not printed_file:

2128

if not printed_file:

2127

ui.warn(pf + '\n')

2129

ui.warn(pf + '\n')

2128

printed_file = True

2130

printed_file = True

2129

ui.warn(line + '\n')

2131

ui.warn(line + '\n')

2130

finally:

2132

finally:

2131

if files:

2133

if files:

2132

scmutil.marktouched(repo, files, similarity)

2134

scmutil.marktouched(repo, files, similarity)

2133

code = fp.close()

2135

code = fp.close()

2134

if code:

2136

if code:

2135

raise PatchError(_("patch command failed: %s") %

2137

raise PatchError(_("patch command failed: %s") %

2136

procutil.explainexit(code))

2138

procutil.explainexit(code))

2137

return fuzz

2139

return fuzz

2138

2140

2139

def patchbackend(ui, backend, patchobj, strip, prefix, files=None,

2141

def patchbackend(ui, backend, patchobj, strip, prefix, files=None,

2140

eolmode='strict'):

2142

eolmode='strict'):

2141

if files is None:

2143

if files is None:

2142

files = set()

2144

files = set()

2143

if eolmode is None:

2145

if eolmode is None:

2144

eolmode = ui.config('patch', 'eol')

2146

eolmode = ui.config('patch', 'eol')

2145

if eolmode.lower() not in eolmodes:

2147

if eolmode.lower() not in eolmodes:

2146

raise error.Abort(_('unsupported line endings type: %s') % eolmode)

2148

raise error.Abort(_('unsupported line endings type: %s') % eolmode)

2147

eolmode = eolmode.lower()

2149

eolmode = eolmode.lower()

2148

2150

2149

store = filestore()

2151

store = filestore()

2150

try:

2152

try:

2151

fp = open(patchobj, 'rb')

2153

fp = open(patchobj, 'rb')

2152

except TypeError:

2154

except TypeError:

2153

fp = patchobj

2155

fp = patchobj

2154

try:

2156

try:

2155

ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix,

2157

ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix,

2156

eolmode=eolmode)

2158

eolmode=eolmode)

2157

finally:

2159

finally:

2158

if fp != patchobj:

2160

if fp != patchobj:

2159

fp.close()

2161

fp.close()

2160

files.update(backend.close())

2162

files.update(backend.close())

2161

store.close()

2163

store.close()

2162

if ret < 0:

2164

if ret < 0:

2163

raise PatchError(_('patch failed to apply'))

2165

raise PatchError(_('patch failed to apply'))

2164

return ret > 0

2166

return ret > 0

2165

2167

2166

def internalpatch(ui, repo, patchobj, strip, prefix='', files=None,

2168

def internalpatch(ui, repo, patchobj, strip, prefix='', files=None,

2167

eolmode='strict', similarity=0):

2169

eolmode='strict', similarity=0):

2168

"""use builtin patch to apply <patchobj> to the working directory.

2170

"""use builtin patch to apply <patchobj> to the working directory.

2169

returns whether patch was applied with fuzz factor."""

2171

returns whether patch was applied with fuzz factor."""

2170

backend = workingbackend(ui, repo, similarity)

2172

backend = workingbackend(ui, repo, similarity)

2171

return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)

2173

return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)

2172

2174

2173

def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None,

2175

def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None,

2174

eolmode='strict'):

2176

eolmode='strict'):

2175

backend = repobackend(ui, repo, ctx, store)

2177

backend = repobackend(ui, repo, ctx, store)

2176

return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)

2178

return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)

2177

2179

2178

def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict',

2180

def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict',

2179

similarity=0):

2181

similarity=0):

2180

"""Apply <patchname> to the working directory.

2182

"""Apply <patchname> to the working directory.

2181

2183

2182

'eolmode' specifies how end of lines should be handled. It can be:

2184

'eolmode' specifies how end of lines should be handled. It can be:

2183

- 'strict': inputs are read in binary mode, EOLs are preserved

2185

- 'strict': inputs are read in binary mode, EOLs are preserved

2184

- 'crlf': EOLs are ignored when patching and reset to CRLF

2186

- 'crlf': EOLs are ignored when patching and reset to CRLF

2185

- 'lf': EOLs are ignored when patching and reset to LF

2187

- 'lf': EOLs are ignored when patching and reset to LF

2186

- None: get it from user settings, default to 'strict'

2188

- None: get it from user settings, default to 'strict'

2187

'eolmode' is ignored when using an external patcher program.

2189

'eolmode' is ignored when using an external patcher program.

2188

2190

2189

Returns whether patch was applied with fuzz factor.

2191

Returns whether patch was applied with fuzz factor.

2190

"""

2192

"""

2191

patcher = ui.config('ui', 'patch')

2193

patcher = ui.config('ui', 'patch')

2192

if files is None:

2194

if files is None:

2193

files = set()

2195

files = set()

2194

if patcher:

2196

if patcher:

2195

return _externalpatch(ui, repo, patcher, patchname, strip,

2197

return _externalpatch(ui, repo, patcher, patchname, strip,

2196

files, similarity)

2198

files, similarity)

2197

return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode,

2199

return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode,

2198

similarity)

2200

similarity)

2199

2201

2200

def changedfiles(ui, repo, patchpath, strip=1, prefix=''):

2202

def changedfiles(ui, repo, patchpath, strip=1, prefix=''):

2201

backend = fsbackend(ui, repo.root)

2203

backend = fsbackend(ui, repo.root)

2202

prefix = _canonprefix(repo, prefix)

2204

prefix = _canonprefix(repo, prefix)

2203

with open(patchpath, 'rb') as fp:

2205

with open(patchpath, 'rb') as fp:

2204

changed = set()

2206

changed = set()

2205

for state, values in iterhunks(fp):

2207

for state, values in iterhunks(fp):

2206

if state == 'file':

2208

if state == 'file':

2207

afile, bfile, first_hunk, gp = values

2209

afile, bfile, first_hunk, gp = values

2208

if gp:

2210

if gp:

2209

gp.path = pathtransform(gp.path, strip - 1, prefix)[1]

2211

gp.path = pathtransform(gp.path, strip - 1, prefix)[1]

2210

if gp.oldpath:

2212

if gp.oldpath:

2211

gp.oldpath = pathtransform(gp.oldpath, strip - 1,

2213

gp.oldpath = pathtransform(gp.oldpath, strip - 1,

2212

prefix)[1]

2214

prefix)[1]

2213

else:

2215

else:

2214

gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,

2216

gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,

2215

prefix)

2217

prefix)

2216

changed.add(gp.path)

2218

changed.add(gp.path)

2217

if gp.op == 'RENAME':

2219

if gp.op == 'RENAME':

2218

changed.add(gp.oldpath)

2220

changed.add(gp.oldpath)

2219

elif state not in ('hunk', 'git'):

2221

elif state not in ('hunk', 'git'):

2220

raise error.Abort(_('unsupported parser state: %s') % state)

2222

raise error.Abort(_('unsupported parser state: %s') % state)

2221

return changed

2223

return changed

2222

2224

2223

class GitDiffRequired(Exception):

2225

class GitDiffRequired(Exception):

2224

pass

2226

pass

2225

2227

2226

def diffallopts(ui, opts=None, untrusted=False, section='diff'):

2228

def diffallopts(ui, opts=None, untrusted=False, section='diff'):

2227

'''return diffopts with all features supported and parsed'''

2229

'''return diffopts with all features supported and parsed'''

2228

return difffeatureopts(ui, opts=opts, untrusted=untrusted, section=section,

2230

return difffeatureopts(ui, opts=opts, untrusted=untrusted, section=section,

2229

git=True, whitespace=True, formatchanging=True)

2231

git=True, whitespace=True, formatchanging=True)

2230

2232

2231

diffopts = diffallopts

2233

diffopts = diffallopts

2232

2234

2233

def difffeatureopts(ui, opts=None, untrusted=False, section='diff', git=False,

2235

def difffeatureopts(ui, opts=None, untrusted=False, section='diff', git=False,

2234

whitespace=False, formatchanging=False):

2236

whitespace=False, formatchanging=False):

2235

'''return diffopts with only opted-in features parsed

2237

'''return diffopts with only opted-in features parsed

2236

2238

2237

Features:

2239

Features:

2238

- git: git-style diffs

2240

- git: git-style diffs

2239

- whitespace: whitespace options like ignoreblanklines and ignorews

2241

- whitespace: whitespace options like ignoreblanklines and ignorews

2240

- formatchanging: options that will likely break or cause correctness issues

2242

- formatchanging: options that will likely break or cause correctness issues

2241

with most diff parsers

2243

with most diff parsers

2242

'''

2244

'''

2243

def get(key, name=None, getter=ui.configbool, forceplain=None):

2245

def get(key, name=None, getter=ui.configbool, forceplain=None):

2244

if opts:

2246

if opts:

2245

v = opts.get(key)

2247

v = opts.get(key)

2246

# diffopts flags are either None-default (which is passed

2248

# diffopts flags are either None-default (which is passed

2247

# through unchanged, so we can identify unset values), or

2249

# through unchanged, so we can identify unset values), or

2248

# some other falsey default (eg --unified, which defaults

2250

# some other falsey default (eg --unified, which defaults

2249

# to an empty string). We only want to override the config

2251

# to an empty string). We only want to override the config

2250

# entries from hgrc with command line values if they

2252

# entries from hgrc with command line values if they

2251

# appear to have been set, which is any truthy value,

2253

# appear to have been set, which is any truthy value,

2252

# True, or False.

2254

# True, or False.

2253

if v or isinstance(v, bool):

2255

if v or isinstance(v, bool):

2254

return v

2256

return v

2255

if forceplain is not None and ui.plain():

2257

if forceplain is not None and ui.plain():

2256

return forceplain

2258

return forceplain

2257

return getter(section, name or key, untrusted=untrusted)

2259

return getter(section, name or key, untrusted=untrusted)

2258

2260

2259

# core options, expected to be understood by every diff parser

2261

# core options, expected to be understood by every diff parser

2260

buildopts = {

2262

buildopts = {

2261

'nodates': get('nodates'),

2263

'nodates': get('nodates'),

2262

'showfunc': get('show_function', 'showfunc'),

2264

'showfunc': get('show_function', 'showfunc'),

2263

'context': get('unified', getter=ui.config),

2265

'context': get('unified', getter=ui.config),

2264

}

2266

}

2265

buildopts['worddiff'] = ui.configbool('experimental', 'worddiff')

2267

buildopts['worddiff'] = ui.configbool('experimental', 'worddiff')

2266

buildopts['xdiff'] = ui.configbool('experimental', 'xdiff')

2268

buildopts['xdiff'] = ui.configbool('experimental', 'xdiff')

2267

2269

2268

if git:

2270

if git:

2269

buildopts['git'] = get('git')

2271

buildopts['git'] = get('git')

2270

2272

2271

# since this is in the experimental section, we need to call

2273

# since this is in the experimental section, we need to call

2272

# ui.configbool directory

2274

# ui.configbool directory

2273

buildopts['showsimilarity'] = ui.configbool('experimental',

2275

buildopts['showsimilarity'] = ui.configbool('experimental',

2274

'extendedheader.similarity')

2276

'extendedheader.similarity')

2275

2277

2276

# need to inspect the ui object instead of using get() since we want to

2278

# need to inspect the ui object instead of using get() since we want to

2277

# test for an int

2279

# test for an int

2278

hconf = ui.config('experimental', 'extendedheader.index')

2280

hconf = ui.config('experimental', 'extendedheader.index')

2279

if hconf is not None:

2281

if hconf is not None:

2280

hlen = None

2282

hlen = None

2281

try:

2283

try:

2282

# the hash config could be an integer (for length of hash) or a

2284

# the hash config could be an integer (for length of hash) or a

2283

# word (e.g. short, full, none)

2285

# word (e.g. short, full, none)

2284

hlen = int(hconf)

2286

hlen = int(hconf)

2285

if hlen < 0 or hlen > 40:

2287

if hlen < 0 or hlen > 40:

2286

msg = _("invalid length for extendedheader.index: '%d'\n")

2288

msg = _("invalid length for extendedheader.index: '%d'\n")

2287

ui.warn(msg % hlen)

2289

ui.warn(msg % hlen)

2288

except ValueError:

2290

except ValueError:

2289

# default value

2291

# default value

2290

if hconf == 'short' or hconf == '':

2292

if hconf == 'short' or hconf == '':

2291

hlen = 12

2293

hlen = 12

2292

elif hconf == 'full':

2294

elif hconf == 'full':

2293

hlen = 40

2295

hlen = 40

2294

elif hconf != 'none':

2296

elif hconf != 'none':

2295

msg = _("invalid value for extendedheader.index: '%s'\n")

2297

msg = _("invalid value for extendedheader.index: '%s'\n")

2296

ui.warn(msg % hconf)

2298

ui.warn(msg % hconf)

2297

finally:

2299

finally:

2298

buildopts['index'] = hlen

2300

buildopts['index'] = hlen

2299

2301

2300

if whitespace:

2302

if whitespace:

2301

buildopts['ignorews'] = get('ignore_all_space', 'ignorews')

2303

buildopts['ignorews'] = get('ignore_all_space', 'ignorews')

2302

buildopts['ignorewsamount'] = get('ignore_space_change',

2304

buildopts['ignorewsamount'] = get('ignore_space_change',

2303

'ignorewsamount')

2305

'ignorewsamount')

2304

buildopts['ignoreblanklines'] = get('ignore_blank_lines',

2306

buildopts['ignoreblanklines'] = get('ignore_blank_lines',

2305

'ignoreblanklines')

2307

'ignoreblanklines')

2306

buildopts['ignorewseol'] = get('ignore_space_at_eol', 'ignorewseol')

2308

buildopts['ignorewseol'] = get('ignore_space_at_eol', 'ignorewseol')

2307

if formatchanging:

2309

if formatchanging:

2308

buildopts['text'] = opts and opts.get('text')

2310

buildopts['text'] = opts and opts.get('text')

2309

binary = None if opts is None else opts.get('binary')

2311

binary = None if opts is None else opts.get('binary')

2310

buildopts['nobinary'] = (not binary if binary is not None

2312

buildopts['nobinary'] = (not binary if binary is not None

2311

else get('nobinary', forceplain=False))

2313

else get('nobinary', forceplain=False))

2312

buildopts['noprefix'] = get('noprefix', forceplain=False)

2314

buildopts['noprefix'] = get('noprefix', forceplain=False)

2313

2315

2314

return mdiff.diffopts(**pycompat.strkwargs(buildopts))

2316

return mdiff.diffopts(**pycompat.strkwargs(buildopts))

2315

2317

2316

def diff(repo, node1=None, node2=None, match=None, changes=None,

2318

def diff(repo, node1=None, node2=None, match=None, changes=None,

2317

opts=None, losedatafn=None, prefix='', relroot='', copy=None,

2319

opts=None, losedatafn=None, prefix='', relroot='', copy=None,

2318

hunksfilterfn=None):

2320

hunksfilterfn=None):

2319

'''yields diff of changes to files between two nodes, or node and

2321

'''yields diff of changes to files between two nodes, or node and

2320

working directory.

2322

working directory.

2321

2323

2322

if node1 is None, use first dirstate parent instead.

2324

if node1 is None, use first dirstate parent instead.

2323

if node2 is None, compare node1 with working directory.

2325

if node2 is None, compare node1 with working directory.

2324

2326

2325

losedatafn(**kwarg) is a callable run when opts.upgrade=True and

2327

losedatafn(**kwarg) is a callable run when opts.upgrade=True and

2326

every time some change cannot be represented with the current

2328

every time some change cannot be represented with the current

2327

patch format. Return False to upgrade to git patch format, True to

2329

patch format. Return False to upgrade to git patch format, True to

2328

accept the loss or raise an exception to abort the diff. It is

2330

accept the loss or raise an exception to abort the diff. It is

2329

called with the name of current file being diffed as 'fn'. If set

2331

called with the name of current file being diffed as 'fn'. If set

2330

to None, patches will always be upgraded to git format when

2332

to None, patches will always be upgraded to git format when

2331

necessary.

2333

necessary.

2332

2334

2333

prefix is a filename prefix that is prepended to all filenames on

2335

prefix is a filename prefix that is prepended to all filenames on

2334

display (used for subrepos).

2336

display (used for subrepos).

2335

2337

2336

relroot, if not empty, must be normalized with a trailing /. Any match

2338

relroot, if not empty, must be normalized with a trailing /. Any match

2337

patterns that fall outside it will be ignored.

2339

patterns that fall outside it will be ignored.

2338

2340

2339

copy, if not empty, should contain mappings {dst@y: src@x} of copy

2341

copy, if not empty, should contain mappings {dst@y: src@x} of copy

2340

information.

2342

information.

2341

2343

2342

hunksfilterfn, if not None, should be a function taking a filectx and

2344

hunksfilterfn, if not None, should be a function taking a filectx and

2343

hunks generator that may yield filtered hunks.

2345

hunks generator that may yield filtered hunks.

2344

'''

2346

'''

2345

for fctx1, fctx2, hdr, hunks in diffhunks(

2347

for fctx1, fctx2, hdr, hunks in diffhunks(

2346

repo, node1=node1, node2=node2,

2348

repo, node1=node1, node2=node2,

2347

match=match, changes=changes, opts=opts,

2349

match=match, changes=changes, opts=opts,

2348

losedatafn=losedatafn, prefix=prefix, relroot=relroot, copy=copy,

2350

losedatafn=losedatafn, prefix=prefix, relroot=relroot, copy=copy,

2349

):

2351

):

2350

if hunksfilterfn is not None:

2352

if hunksfilterfn is not None:

2351

# If the file has been removed, fctx2 is None; but this should

2353

# If the file has been removed, fctx2 is None; but this should

2352

# not occur here since we catch removed files early in

2354

# not occur here since we catch removed files early in

2353

# logcmdutil.getlinerangerevs() for 'hg log -L'.

2355

# logcmdutil.getlinerangerevs() for 'hg log -L'.

2354

assert fctx2 is not None, \

2356

assert fctx2 is not None, \

2355

'fctx2 unexpectly None in diff hunks filtering'

2357

'fctx2 unexpectly None in diff hunks filtering'

2356

hunks = hunksfilterfn(fctx2, hunks)

2358

hunks = hunksfilterfn(fctx2, hunks)

2357

text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))

2359

text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))

2358

if hdr and (text or len(hdr) > 1):

2360

if hdr and (text or len(hdr) > 1):

2359

yield '\n'.join(hdr) + '\n'

2361

yield '\n'.join(hdr) + '\n'

2360

if text:

2362

if text:

2361

yield text

2363

yield text

2362

2364

2363

def diffhunks(repo, node1=None, node2=None, match=None, changes=None,

2365

def diffhunks(repo, node1=None, node2=None, match=None, changes=None,

2364

opts=None, losedatafn=None, prefix='', relroot='', copy=None):

2366

opts=None, losedatafn=None, prefix='', relroot='', copy=None):

2365

"""Yield diff of changes to files in the form of (`header`, `hunks`) tuples

2367

"""Yield diff of changes to files in the form of (`header`, `hunks`) tuples

2366

where `header` is a list of diff headers and `hunks` is an iterable of

2368

where `header` is a list of diff headers and `hunks` is an iterable of

2367

(`hunkrange`, `hunklines`) tuples.

2369

(`hunkrange`, `hunklines`) tuples.

2368

2370

2369

See diff() for the meaning of parameters.

2371

See diff() for the meaning of parameters.

2370

"""

2372

"""

2371

2373

2372

if opts is None:

2374

if opts is None:

2373

opts = mdiff.defaultopts

2375

opts = mdiff.defaultopts

2374

2376

2375

if not node1 and not node2:

2377

if not node1 and not node2:

2376

node1 = repo.dirstate.p1()

2378

node1 = repo.dirstate.p1()

2377

2379

2378

def lrugetfilectx():

2380

def lrugetfilectx():

2379

cache = {}

2381

cache = {}

2380

order = collections.deque()

2382

order = collections.deque()

2381

def getfilectx(f, ctx):

2383

def getfilectx(f, ctx):

2382

fctx = ctx.filectx(f, filelog=cache.get(f))

2384

fctx = ctx.filectx(f, filelog=cache.get(f))

2383

if f not in cache:

2385

if f not in cache:

2384

if len(cache) > 20:

2386

if len(cache) > 20:

2385

del cache[order.popleft()]

2387

del cache[order.popleft()]

2386

cache[f] = fctx.filelog()

2388

cache[f] = fctx.filelog()

2387

else:

2389

else:

2388

order.remove(f)

2390

order.remove(f)

2389

order.append(f)

2391

order.append(f)

2390

return fctx

2392

return fctx

2391

return getfilectx

2393

return getfilectx

2392

getfilectx = lrugetfilectx()

2394

getfilectx = lrugetfilectx()

2393

2395

2394

ctx1 = repo[node1]

2396

ctx1 = repo[node1]

2395

ctx2 = repo[node2]

2397

ctx2 = repo[node2]

2396

2398

2397

relfiltered = False

2399

relfiltered = False

2398

if relroot != '' and match.always():

2400

if relroot != '' and match.always():

2399

# as a special case, create a new matcher with just the relroot

2401

# as a special case, create a new matcher with just the relroot

2400

pats = [relroot]

2402

pats = [relroot]

2401

match = scmutil.match(ctx2, pats, default='path')

2403

match = scmutil.match(ctx2, pats, default='path')

2402

relfiltered = True

2404

relfiltered = True

2403

2405

2404

if not changes:

2406

if not changes:

2405

changes = repo.status(ctx1, ctx2, match=match)

2407

changes = repo.status(ctx1, ctx2, match=match)

2406

modified, added, removed = changes[:3]

2408

modified, added, removed = changes[:3]

2407

2409

2408

if not modified and not added and not removed:

2410

if not modified and not added and not removed:

2409

return []

2411

return []

2410

2412

2411

if repo.ui.debugflag:

2413

if repo.ui.debugflag:

2412

hexfunc = hex

2414

hexfunc = hex

2413

else:

2415

else:

2414

hexfunc = short

2416

hexfunc = short

2415

revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]

2417

revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]

2416

2418

2417

if copy is None:

2419

if copy is None:

2418

copy = {}

2420

copy = {}

2419

if opts.git or opts.upgrade:

2421

if opts.git or opts.upgrade:

2420

copy = copies.pathcopies(ctx1, ctx2, match=match)

2422

copy = copies.pathcopies(ctx1, ctx2, match=match)

2421

2423

2422

if relroot is not None:

2424

if relroot is not None:

2423

if not relfiltered:

2425

if not relfiltered:

2424

# XXX this would ideally be done in the matcher, but that is

2426

# XXX this would ideally be done in the matcher, but that is

2425

# generally meant to 'or' patterns, not 'and' them. In this case we

2427

# generally meant to 'or' patterns, not 'and' them. In this case we

2426

# need to 'and' all the patterns from the matcher with relroot.

2428

# need to 'and' all the patterns from the matcher with relroot.

2427

def filterrel(l):

2429

def filterrel(l):

2428

return [f for f in l if f.startswith(relroot)]

2430

return [f for f in l if f.startswith(relroot)]

2429

modified = filterrel(modified)

2431

modified = filterrel(modified)

2430

added = filterrel(added)

2432

added = filterrel(added)

2431

removed = filterrel(removed)

2433

removed = filterrel(removed)

2432

relfiltered = True

2434

relfiltered = True

2433

# filter out copies where either side isn't inside the relative root

2435

# filter out copies where either side isn't inside the relative root

2434

copy = dict(((dst, src) for (dst, src) in copy.iteritems()

2436

copy = dict(((dst, src) for (dst, src) in copy.iteritems()

2435

if dst.startswith(relroot)

2437

if dst.startswith(relroot)

2436

and src.startswith(relroot)))

2438

and src.startswith(relroot)))

2437

2439

2438

modifiedset = set(modified)

2440

modifiedset = set(modified)

2439

addedset = set(added)

2441

addedset = set(added)

2440

removedset = set(removed)

2442

removedset = set(removed)

2441

for f in modified:

2443

for f in modified:

2442

if f not in ctx1:

2444

if f not in ctx1:

2443

# Fix up added, since merged-in additions appear as

2445

# Fix up added, since merged-in additions appear as

2444

# modifications during merges

2446

# modifications during merges

2445

modifiedset.remove(f)

2447

modifiedset.remove(f)

2446

addedset.add(f)

2448

addedset.add(f)

2447

for f in removed:

2449

for f in removed:

2448

if f not in ctx1:

2450

if f not in ctx1:

2449

# Merged-in additions that are then removed are reported as removed.

2451

# Merged-in additions that are then removed are reported as removed.

2450

# They are not in ctx1, so We don't want to show them in the diff.

2452

# They are not in ctx1, so We don't want to show them in the diff.

2451

removedset.remove(f)

2453

removedset.remove(f)

2452

modified = sorted(modifiedset)

2454

modified = sorted(modifiedset)

2453

added = sorted(addedset)

2455

added = sorted(addedset)

2454

removed = sorted(removedset)

2456

removed = sorted(removedset)

2455

for dst, src in list(copy.items()):

2457

for dst, src in list(copy.items()):

2456

if src not in ctx1:

2458

if src not in ctx1:

2457

# Files merged in during a merge and then copied/renamed are

2459

# Files merged in during a merge and then copied/renamed are

2458

# reported as copies. We want to show them in the diff as additions.

2460

# reported as copies. We want to show them in the diff as additions.

2459

del copy[dst]

2461

del copy[dst]

2460

2462

2461

def difffn(opts, losedata):

2463

def difffn(opts, losedata):

2462

return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,

2464

return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,

2463

copy, getfilectx, opts, losedata, prefix, relroot)

2465

copy, getfilectx, opts, losedata, prefix, relroot)

2464

if opts.upgrade and not opts.git:

2466

if opts.upgrade and not opts.git:

2465

try:

2467

try:

2466

def losedata(fn):

2468

def losedata(fn):

2467

if not losedatafn or not losedatafn(fn=fn):

2469

if not losedatafn or not losedatafn(fn=fn):

2468

raise GitDiffRequired

2470

raise GitDiffRequired

2469

# Buffer the whole output until we are sure it can be generated

2471

# Buffer the whole output until we are sure it can be generated

2470

return list(difffn(opts.copy(git=False), losedata))

2472

return list(difffn(opts.copy(git=False), losedata))

2471

except GitDiffRequired:

2473

except GitDiffRequired:

2472

return difffn(opts.copy(git=True), None)

2474

return difffn(opts.copy(git=True), None)

2473

else:

2475

else:

2474

return difffn(opts, None)

2476

return difffn(opts, None)

2475

2477

2476

def difflabel(func, *args, **kw):

2478

def difflabel(func, *args, **kw):

2477

'''yields 2-tuples of (output, label) based on the output of func()'''

2479

'''yields 2-tuples of (output, label) based on the output of func()'''

2478

inlinecolor = False

2480

inlinecolor = False

2479

if kw.get(r'opts'):

2481

if kw.get(r'opts'):

2480

inlinecolor = kw[r'opts'].worddiff

2482

inlinecolor = kw[r'opts'].worddiff

2481

headprefixes = [('diff', 'diff.diffline'),

2483

headprefixes = [('diff', 'diff.diffline'),

2482

('copy', 'diff.extended'),

2484

('copy', 'diff.extended'),

2483

('rename', 'diff.extended'),

2485

('rename', 'diff.extended'),

2484

('old', 'diff.extended'),

2486

('old', 'diff.extended'),

2485

('new', 'diff.extended'),

2487

('new', 'diff.extended'),

2486

('deleted', 'diff.extended'),

2488

('deleted', 'diff.extended'),

2487

('index', 'diff.extended'),

2489

('index', 'diff.extended'),

2488

('similarity', 'diff.extended'),

2490

('similarity', 'diff.extended'),

2489

('---', 'diff.file_a'),

2491

('---', 'diff.file_a'),

2490

('+++', 'diff.file_b')]

2492

('+++', 'diff.file_b')]

2491

textprefixes = [('@', 'diff.hunk'),

2493

textprefixes = [('@', 'diff.hunk'),

2492

('-', 'diff.deleted'),

2494

('-', 'diff.deleted'),

2493

('+', 'diff.inserted')]

2495

('+', 'diff.inserted')]

2494

head = False

2496

head = False

2495

for chunk in func(*args, **kw):

2497

for chunk in func(*args, **kw):

2496

lines = chunk.split('\n')

2498

lines = chunk.split('\n')

2497

matches = {}

2499

matches = {}

2498

if inlinecolor:

2500

if inlinecolor:

2499

matches = _findmatches(lines)

2501

matches = _findmatches(lines)

2500

for i, line in enumerate(lines):

2502

for i, line in enumerate(lines):

2501

if i != 0:

2503

if i != 0:

2502

yield ('\n', '')

2504

yield ('\n', '')

2503

if head:

2505

if head:

2504

if line.startswith('@'):

2506

if line.startswith('@'):

2505

head = False

2507

head = False

2506

else:

2508

else:

2507

if line and ~~line~~[0] not in ' +-@\\':

2509

if line and not line.startswith((' ', '+', '-', '@', '\\')):

2508

head = True

2510

head = True

2509

stripline = line

2511

stripline = line

2510

diffline = False

2512

diffline = False

2511

if not head and line and line[0] in '+-':

2513

if not head and line and line.startswith(('+', '-')):

2512

# highlight tabs and trailing whitespace, but only in

2514

# highlight tabs and trailing whitespace, but only in

2513

# changed lines

2515

# changed lines

2514

stripline = line.rstrip()

2516

stripline = line.rstrip()

2515

diffline = True

2517

diffline = True

2516

2518

2517

prefixes = textprefixes

2519

prefixes = textprefixes

2518

if head:

2520

if head:

2519

prefixes = headprefixes

2521

prefixes = headprefixes

2520

for prefix, label in prefixes:

2522

for prefix, label in prefixes:

2521

if stripline.startswith(prefix):

2523

if stripline.startswith(prefix):

2522

if diffline:

2524

if diffline:

2523

if i in matches:

2525

if i in matches:

2524

for t, l in _inlinediff(lines[i].rstrip(),

2526

for t, l in _inlinediff(lines[i].rstrip(),

2525

lines[matches[i]].rstrip(),

2527

lines[matches[i]].rstrip(),

2526

label):

2528

label):

2527

yield (t, l)

2529

yield (t, l)

2528

else:

2530

else:

2529

for token in tabsplitter.findall(stripline):

2531

for token in tabsplitter.findall(stripline):

2530

if token.startswith('\t'):

2532

if token.startswith('\t'):

2531

yield (token, 'diff.tab')

2533

yield (token, 'diff.tab')

2532

else:

2534

else:

2533

yield (token, label)

2535

yield (token, label)

2534

else:

2536

else:

2535

yield (stripline, label)

2537

yield (stripline, label)

2536

break

2538

break

2537

else:

2539

else:

2538

yield (line, '')

2540

yield (line, '')

2539

if line != stripline:

2541

if line != stripline:

2540

yield (line[len(stripline):], 'diff.trailingwhitespace')

2542

yield (line[len(stripline):], 'diff.trailingwhitespace')

2541

2543

2542

def _findmatches(slist):

2544

def _findmatches(slist):

2543

'''Look for insertion matches to deletion and returns a dict of

2545

'''Look for insertion matches to deletion and returns a dict of

2544

correspondences.

2546

correspondences.

2545

'''

2547

'''

2546

lastmatch = 0

2548

lastmatch = 0

2547

matches = {}

2549

matches = {}

2548

for i, line in enumerate(slist):

2550

for i, line in enumerate(slist):

2549

if line == '':

2551

if line == '':

2550

continue

2552

continue

2551

if line[0] == '-':

2553

if line.startswith('-'):

2552

lastmatch = max(lastmatch, i)

2554

lastmatch = max(lastmatch, i)

2553

newgroup = False

2555

newgroup = False

2554

for j, newline in enumerate(slist[lastmatch + 1:]):

2556

for j, newline in enumerate(slist[lastmatch + 1:]):

2555

if newline == '':

2557

if newline == '':

2556

continue

2558

continue

2557

if newline[0] == '-' and newgroup: # too far, no match

2559

if newline.startswith('-') and newgroup: # too far, no match

2558

break

2560

break

2559

if newline[0] == '+': # potential match

2561

if newline.startswith('+'): # potential match

2560

newgroup = True

2562

newgroup = True

2561

sim = difflib.SequenceMatcher(None, line, newline).ratio()

2563

sim = difflib.SequenceMatcher(None, line, newline).ratio()

2562

if sim > 0.7:

2564

if sim > 0.7:

2563

lastmatch = lastmatch + 1 + j

2565

lastmatch = lastmatch + 1 + j

2564

matches[i] = lastmatch

2566

matches[i] = lastmatch

2565

matches[lastmatch] = i

2567

matches[lastmatch] = i

2566

break

2568

break

2567

return matches

2569

return matches

2568

2570

2569

def _inlinediff(s1, s2, operation):

2571

def _inlinediff(s1, s2, operation):

2570

'''Perform string diff to highlight specific changes.'''

2572

'''Perform string diff to highlight specific changes.'''

2571

operation_skip = '+?' if operation == 'diff.deleted' else '-?'

2573

operation_skip = ('+', '?') if operation == 'diff.deleted' else ('-', '?')

2572

if operation == 'diff.deleted':

2574

if operation == 'diff.deleted':

2573

s2, s1 = s1, s2

2575

s2, s1 = s1, s2

2574

2576

2575

buff = []

2577

buff = []

2576

# we never want to higlight the leading +-

2578

# we never want to higlight the leading +-

2577

if operation == 'diff.deleted' and s2.startswith('-'):

2579

if operation == 'diff.deleted' and s2.startswith('-'):

2578

label = operation

2580

label = operation

2579

token = '-'

2581

token = '-'

2580

s2 = s2[1:]

2582

s2 = s2[1:]

2581

s1 = s1[1:]

2583

s1 = s1[1:]

2582

elif operation == 'diff.inserted' and s1.startswith('+'):

2584

elif operation == 'diff.inserted' and s1.startswith('+'):

2583

label = operation

2585

label = operation

2584

token = '+'

2586

token = '+'

2585

s2 = s2[1:]

2587

s2 = s2[1:]

2586

s1 = s1[1:]

2588

s1 = s1[1:]

2587

else:

2589

else:

2588

raise error.ProgrammingError("Case not expected, operation = %s" %

2590

raise error.ProgrammingError("Case not expected, operation = %s" %

2589

operation)

2591

operation)

2590

2592

2591

s = difflib.ndiff(_nonwordre.split(s2), _nonwordre.split(s1))

2593

s = difflib.ndiff(_nonwordre.split(s2), _nonwordre.split(s1))

2592

for part in s:

2594

for part in s:

2593

if part[0] in operation_skip or len(part) == 2:

2595

if part.startswith(operation_skip) or len(part) == 2:

2594

continue

2596

continue

2595

l = operation + '.highlight'

2597

l = operation + '.highlight'

2596

if part[0] in ' ':

2598

if part.startswith(' '):

2597

l = operation

2599

l = operation

2598

if part[2:] == '\t':

2600

if part[2:] == '\t':

2599

l = 'diff.tab'

2601

l = 'diff.tab'

2600

if l == label: # contiguous token with same label

2602

if l == label: # contiguous token with same label

2601

token += part[2:]

2603

token += part[2:]

2602

continue

2604

continue

2603

else:

2605

else:

2604

buff.append((token, label))

2606

buff.append((token, label))

2605

label = l

2607

label = l

2606

token = part[2:]

2608

token = part[2:]

2607

buff.append((token, label))

2609

buff.append((token, label))

2608

2610

2609

return buff

2611

return buff

2610

2612

2611

def diffui(*args, **kw):

2613

def diffui(*args, **kw):

2612

'''like diff(), but yields 2-tuples of (output, label) for ui.write()'''

2614

'''like diff(), but yields 2-tuples of (output, label) for ui.write()'''

2613

return difflabel(diff, *args, **kw)

2615

return difflabel(diff, *args, **kw)

2614

2616

2615

def _filepairs(modified, added, removed, copy, opts):

2617

def _filepairs(modified, added, removed, copy, opts):

2616

'''generates tuples (f1, f2, copyop), where f1 is the name of the file

2618

'''generates tuples (f1, f2, copyop), where f1 is the name of the file

2617

before and f2 is the the name after. For added files, f1 will be None,

2619

before and f2 is the the name after. For added files, f1 will be None,

2618

and for removed files, f2 will be None. copyop may be set to None, 'copy'

2620

and for removed files, f2 will be None. copyop may be set to None, 'copy'

2619

or 'rename' (the latter two only if opts.git is set).'''

2621

or 'rename' (the latter two only if opts.git is set).'''

2620

gone = set()

2622

gone = set()

2621

2623

2622

copyto = dict([(v, k) for k, v in copy.items()])

2624

copyto = dict([(v, k) for k, v in copy.items()])

2623

2625

2624

addedset, removedset = set(added), set(removed)

2626

addedset, removedset = set(added), set(removed)

2625

2627

2626

for f in sorted(modified + added + removed):

2628

for f in sorted(modified + added + removed):

2627

copyop = None

2629

copyop = None

2628

f1, f2 = f, f

2630

f1, f2 = f, f

2629

if f in addedset:

2631

if f in addedset:

2630

f1 = None

2632

f1 = None

2631

if f in copy:

2633

if f in copy:

2632

if opts.git:

2634

if opts.git:

2633

f1 = copy[f]

2635

f1 = copy[f]

2634

if f1 in removedset and f1 not in gone:

2636

if f1 in removedset and f1 not in gone:

2635

copyop = 'rename'

2637

copyop = 'rename'

2636

gone.add(f1)

2638

gone.add(f1)

2637

else:

2639

else:

2638

copyop = 'copy'

2640

copyop = 'copy'

2639

elif f in removedset:

2641

elif f in removedset:

2640

f2 = None

2642

f2 = None

2641

if opts.git:

2643

if opts.git:

2642

# have we already reported a copy above?

2644

# have we already reported a copy above?

2643

if (f in copyto and copyto[f] in addedset

2645

if (f in copyto and copyto[f] in addedset

2644

and copy[copyto[f]] == f):

2646

and copy[copyto[f]] == f):

2645

continue

2647

continue

2646

yield f1, f2, copyop

2648

yield f1, f2, copyop

2647

2649

2648

def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,

2650

def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,

2649

copy, getfilectx, opts, losedatafn, prefix, relroot):

2651

copy, getfilectx, opts, losedatafn, prefix, relroot):

2650

'''given input data, generate a diff and yield it in blocks

2652

'''given input data, generate a diff and yield it in blocks

2651

2653

2652

If generating a diff would lose data like flags or binary data and

2654

If generating a diff would lose data like flags or binary data and

2653

losedatafn is not None, it will be called.

2655

losedatafn is not None, it will be called.

2654

2656

2655

relroot is removed and prefix is added to every path in the diff output.

2657

relroot is removed and prefix is added to every path in the diff output.

2656

2658

2657

If relroot is not empty, this function expects every path in modified,

2659

If relroot is not empty, this function expects every path in modified,

2658

added, removed and copy to start with it.'''

2660

added, removed and copy to start with it.'''

2659

2661

2660

def gitindex(text):

2662

def gitindex(text):

2661

if not text:

2663

if not text:

2662

text = ""

2664

text = ""

2663

l = len(text)

2665

l = len(text)

2664

s = hashlib.sha1('blob %d\0' % l)

2666

s = hashlib.sha1('blob %d\0' % l)

2665

s.update(text)

2667

s.update(text)

2666

return hex(s.digest())

2668

return hex(s.digest())

2667

2669

2668

if opts.noprefix:

2670

if opts.noprefix:

2669

aprefix = bprefix = ''

2671

aprefix = bprefix = ''

2670

else:

2672

else:

2671

aprefix = 'a/'

2673

aprefix = 'a/'

2672

bprefix = 'b/'

2674

bprefix = 'b/'

2673

2675

2674

def diffline(f, revs):

2676

def diffline(f, revs):

2675

revinfo = ' '.join(["-r %s" % rev for rev in revs])

2677

revinfo = ' '.join(["-r %s" % rev for rev in revs])

2676

return 'diff %s %s' % (revinfo, f)

2678

return 'diff %s %s' % (revinfo, f)

2677

2679

2678

def isempty(fctx):

2680

def isempty(fctx):

2679

return fctx is None or fctx.size() == 0

2681

return fctx is None or fctx.size() == 0

2680

2682

2681

date1 = dateutil.datestr(ctx1.date())

2683

date1 = dateutil.datestr(ctx1.date())

2682

date2 = dateutil.datestr(ctx2.date())

2684

date2 = dateutil.datestr(ctx2.date())

2683

2685

2684

gitmode = {'l': '120000', 'x': '100755', '': '100644'}

2686

gitmode = {'l': '120000', 'x': '100755', '': '100644'}

2685

2687

2686

if relroot != '' and (repo.ui.configbool('devel', 'all-warnings')

2688

if relroot != '' and (repo.ui.configbool('devel', 'all-warnings')

2687

or repo.ui.configbool('devel', 'check-relroot')):

2689

or repo.ui.configbool('devel', 'check-relroot')):

2688

for f in modified + added + removed + list(copy) + list(copy.values()):

2690

for f in modified + added + removed + list(copy) + list(copy.values()):

2689

if f is not None and not f.startswith(relroot):

2691

if f is not None and not f.startswith(relroot):

2690

raise AssertionError(

2692

raise AssertionError(

2691

"file %s doesn't start with relroot %s" % (f, relroot))

2693

"file %s doesn't start with relroot %s" % (f, relroot))

2692

2694

2693

for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):

2695

for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):

2694

content1 = None

2696

content1 = None

2695

content2 = None

2697

content2 = None

2696

fctx1 = None

2698

fctx1 = None

2697

fctx2 = None

2699

fctx2 = None

2698

flag1 = None

2700

flag1 = None

2699

flag2 = None

2701

flag2 = None

2700

if f1:

2702

if f1:

2701

fctx1 = getfilectx(f1, ctx1)

2703

fctx1 = getfilectx(f1, ctx1)

2702

if opts.git or losedatafn:

2704

if opts.git or losedatafn:

2703

flag1 = ctx1.flags(f1)

2705

flag1 = ctx1.flags(f1)

2704

if f2:

2706

if f2:

2705

fctx2 = getfilectx(f2, ctx2)

2707

fctx2 = getfilectx(f2, ctx2)

2706

if opts.git or losedatafn:

2708

if opts.git or losedatafn:

2707

flag2 = ctx2.flags(f2)

2709

flag2 = ctx2.flags(f2)

2708

# if binary is True, output "summary" or "base85", but not "text diff"

2710

# if binary is True, output "summary" or "base85", but not "text diff"

2709

if opts.text:

2711

if opts.text:

2710

binary = False

2712

binary = False

2711

else:

2713

else:

2712

binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None)

2714

binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None)

2713

2715

2714

if losedatafn and not opts.git:

2716

if losedatafn and not opts.git:

2715

if (binary or

2717

if (binary or

2716

# copy/rename

2718

# copy/rename

2717

f2 in copy or

2719

f2 in copy or

2718

# empty file creation

2720

# empty file creation

2719

(not f1 and isempty(fctx2)) or

2721

(not f1 and isempty(fctx2)) or

2720

# empty file deletion

2722

# empty file deletion

2721

(isempty(fctx1) and not f2) or

2723

(isempty(fctx1) and not f2) or

2722

# create with flags

2724

# create with flags

2723

(not f1 and flag2) or

2725

(not f1 and flag2) or

2724

# change flags

2726

# change flags

2725

(f1 and f2 and flag1 != flag2)):

2727

(f1 and f2 and flag1 != flag2)):

2726

losedatafn(f2 or f1)

2728

losedatafn(f2 or f1)

2727

2729

2728

path1 = f1 or f2

2730

path1 = f1 or f2

2729

path2 = f2 or f1

2731

path2 = f2 or f1

2730

path1 = posixpath.join(prefix, path1[len(relroot):])

2732

path1 = posixpath.join(prefix, path1[len(relroot):])

2731

path2 = posixpath.join(prefix, path2[len(relroot):])

2733

path2 = posixpath.join(prefix, path2[len(relroot):])

2732

header = []

2734

header = []

2733

if opts.git:

2735

if opts.git:

2734

header.append('diff --git %s%s %s%s' %

2736

header.append('diff --git %s%s %s%s' %

2735

(aprefix, path1, bprefix, path2))

2737

(aprefix, path1, bprefix, path2))

2736

if not f1: # added

2738

if not f1: # added

2737

header.append('new file mode %s' % gitmode[flag2])

2739

header.append('new file mode %s' % gitmode[flag2])

2738

elif not f2: # removed

2740

elif not f2: # removed

2739

header.append('deleted file mode %s' % gitmode[flag1])

2741

header.append('deleted file mode %s' % gitmode[flag1])

2740

else: # modified/copied/renamed

2742

else: # modified/copied/renamed

2741

mode1, mode2 = gitmode[flag1], gitmode[flag2]

2743

mode1, mode2 = gitmode[flag1], gitmode[flag2]

2742

if mode1 != mode2:

2744

if mode1 != mode2:

2743

header.append('old mode %s' % mode1)

2745

header.append('old mode %s' % mode1)

2744

header.append('new mode %s' % mode2)

2746

header.append('new mode %s' % mode2)

2745

if copyop is not None:

2747

if copyop is not None:

2746

if opts.showsimilarity:

2748

if opts.showsimilarity:

2747

sim = similar.score(ctx1[path1], ctx2[path2]) * 100

2749

sim = similar.score(ctx1[path1], ctx2[path2]) * 100

2748

header.append('similarity index %d%%' % sim)

2750

header.append('similarity index %d%%' % sim)

2749

header.append('%s from %s' % (copyop, path1))

2751

header.append('%s from %s' % (copyop, path1))

2750

header.append('%s to %s' % (copyop, path2))

2752

header.append('%s to %s' % (copyop, path2))

2751

elif revs and not repo.ui.quiet:

2753

elif revs and not repo.ui.quiet:

2752

header.append(diffline(path1, revs))

2754

header.append(diffline(path1, revs))

2753

2755

2754

# fctx.is | diffopts | what to | is fctx.data()

2756

# fctx.is | diffopts | what to | is fctx.data()

2755

# binary() | text nobinary git index | output? | outputted?

2757

# binary() | text nobinary git index | output? | outputted?

2756

# ------------------------------------|----------------------------

2758

# ------------------------------------|----------------------------

2757

# yes | no no no * | summary | no

2759

# yes | no no no * | summary | no

2758

# yes | no no yes * | base85 | yes

2760

# yes | no no yes * | base85 | yes

2759

# yes | no yes no * | summary | no

2761

# yes | no yes no * | summary | no

2760

# yes | no yes yes 0 | summary | no

2762

# yes | no yes yes 0 | summary | no

2761

# yes | no yes yes >0 | summary | semi [1]

2763

# yes | no yes yes >0 | summary | semi [1]

2762

# yes | yes * * * | text diff | yes

2764

# yes | yes * * * | text diff | yes

2763

# no | * * * * | text diff | yes

2765

# no | * * * * | text diff | yes

2764

# [1]: hash(fctx.data()) is outputted. so fctx.data() cannot be faked

2766

# [1]: hash(fctx.data()) is outputted. so fctx.data() cannot be faked

2765

if binary and (not opts.git or (opts.git and opts.nobinary and not

2767

if binary and (not opts.git or (opts.git and opts.nobinary and not

2766

opts.index)):

2768

opts.index)):

2767

# fast path: no binary content will be displayed, content1 and

2769

# fast path: no binary content will be displayed, content1 and

2768

# content2 are only used for equivalent test. cmp() could have a

2770

# content2 are only used for equivalent test. cmp() could have a

2769

# fast path.

2771

# fast path.

2770

if fctx1 is not None:

2772

if fctx1 is not None:

2771

content1 = b'\0'

2773

content1 = b'\0'

2772

if fctx2 is not None:

2774

if fctx2 is not None:

2773

if fctx1 is not None and not fctx1.cmp(fctx2):

2775

if fctx1 is not None and not fctx1.cmp(fctx2):

2774

content2 = b'\0' # not different

2776

content2 = b'\0' # not different

2775

else:

2777

else:

2776

content2 = b'\0\0'

2778

content2 = b'\0\0'

2777

else:

2779

else:

2778

# normal path: load contents

2780

# normal path: load contents

2779

if fctx1 is not None:

2781

if fctx1 is not None:

2780

content1 = fctx1.data()

2782

content1 = fctx1.data()

2781

if fctx2 is not None:

2783

if fctx2 is not None:

2782

content2 = fctx2.data()

2784

content2 = fctx2.data()

2783

2785

2784

if binary and opts.git and not opts.nobinary:

2786

if binary and opts.git and not opts.nobinary:

2785

text = mdiff.b85diff(content1, content2)

2787

text = mdiff.b85diff(content1, content2)

2786

if text:

2788

if text:

2787

header.append('index %s..%s' %

2789

header.append('index %s..%s' %

2788

(gitindex(content1), gitindex(content2)))

2790

(gitindex(content1), gitindex(content2)))

2789

hunks = (None, [text]),

2791

hunks = (None, [text]),

2790

else:

2792

else:

2791

if opts.git and opts.index > 0:

2793

if opts.git and opts.index > 0:

2792

flag = flag1

2794

flag = flag1

2793

if flag is None:

2795

if flag is None:

2794

flag = flag2

2796

flag = flag2

2795

header.append('index %s..%s %s' %

2797

header.append('index %s..%s %s' %

2796

(gitindex(content1)[0:opts.index],

2798

(gitindex(content1)[0:opts.index],

2797

gitindex(content2)[0:opts.index],

2799

gitindex(content2)[0:opts.index],

2798

gitmode[flag]))

2800

gitmode[flag]))

2799

2801

2800

uheaders, hunks = mdiff.unidiff(content1, date1,

2802

uheaders, hunks = mdiff.unidiff(content1, date1,

2801

content2, date2,

2803

content2, date2,

2802

path1, path2,

2804

path1, path2,

2803

binary=binary, opts=opts)

2805

binary=binary, opts=opts)

2804

header.extend(uheaders)

2806

header.extend(uheaders)

2805

yield fctx1, fctx2, header, hunks

2807

yield fctx1, fctx2, header, hunks

2806

2808

2807

def diffstatsum(stats):

2809

def diffstatsum(stats):

2808

maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False

2810

maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False

2809

for f, a, r, b in stats:

2811

for f, a, r, b in stats:

2810

maxfile = max(maxfile, encoding.colwidth(f))

2812

maxfile = max(maxfile, encoding.colwidth(f))

2811

maxtotal = max(maxtotal, a + r)

2813

maxtotal = max(maxtotal, a + r)

2812

addtotal += a

2814

addtotal += a

2813

removetotal += r

2815

removetotal += r

2814

binary = binary or b

2816

binary = binary or b

2815

2817

2816

return maxfile, maxtotal, addtotal, removetotal, binary

2818

return maxfile, maxtotal, addtotal, removetotal, binary

2817

2819

2818

def diffstatdata(lines):

2820

def diffstatdata(lines):

2819

diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')

2821

diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')

2820

2822

2821

results = []

2823

results = []

2822

filename, adds, removes, isbinary = None, 0, 0, False

2824

filename, adds, removes, isbinary = None, 0, 0, False

2823

2825

2824

def addresult():

2826

def addresult():

2825

if filename:

2827

if filename:

2826

results.append((filename, adds, removes, isbinary))

2828

results.append((filename, adds, removes, isbinary))

2827

2829

2828

# inheader is used to track if a line is in the

2830

# inheader is used to track if a line is in the

2829

# header portion of the diff. This helps properly account

2831

# header portion of the diff. This helps properly account

2830

# for lines that start with '--' or '++'

2832

# for lines that start with '--' or '++'

2831

inheader = False

2833

inheader = False

2832

2834

2833

for line in lines:

2835

for line in lines:

2834

if line.startswith('diff'):

2836

if line.startswith('diff'):

2835

addresult()

2837

addresult()

2836

# starting a new file diff

2838

# starting a new file diff

2837

# set numbers to 0 and reset inheader

2839

# set numbers to 0 and reset inheader

2838

inheader = True

2840

inheader = True

2839

adds, removes, isbinary = 0, 0, False

2841

adds, removes, isbinary = 0, 0, False

2840

if line.startswith('diff --git a/'):

2842

if line.startswith('diff --git a/'):

2841

filename = gitre.search(line).group(2)

2843

filename = gitre.search(line).group(2)

2842

elif line.startswith('diff -r'):

2844

elif line.startswith('diff -r'):

2843

# format: "diff -r ... -r ... filename"

2845

# format: "diff -r ... -r ... filename"

2844

filename = diffre.search(line).group(1)

2846

filename = diffre.search(line).group(1)

2845

elif line.startswith('@@'):

2847

elif line.startswith('@@'):

2846

inheader = False

2848

inheader = False

2847

elif line.startswith('+') and not inheader:

2849

elif line.startswith('+') and not inheader:

2848

adds += 1

2850

adds += 1

2849

elif line.startswith('-') and not inheader:

2851

elif line.startswith('-') and not inheader:

2850

removes += 1

2852

removes += 1

2851

elif (line.startswith('GIT binary patch') or

2853

elif (line.startswith('GIT binary patch') or

2852

line.startswith('Binary file')):

2854

line.startswith('Binary file')):

2853

isbinary = True

2855

isbinary = True

2854

addresult()

2856

addresult()

2855

return results

2857

return results

2856

2858

2857

def diffstat(lines, width=80):

2859

def diffstat(lines, width=80):

2858

output = []

2860

output = []

2859

stats = diffstatdata(lines)

2861

stats = diffstatdata(lines)

2860

maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)

2862

maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)

2861

2863

2862

countwidth = len(str(maxtotal))

2864

countwidth = len(str(maxtotal))

2863

if hasbinary and countwidth < 3:

2865

if hasbinary and countwidth < 3:

2864

countwidth = 3

2866

countwidth = 3

2865

graphwidth = width - countwidth - maxname - 6

2867

graphwidth = width - countwidth - maxname - 6

2866

if graphwidth < 10:

2868

if graphwidth < 10:

2867

graphwidth = 10

2869

graphwidth = 10

2868

2870

2869

def scale(i):

2871

def scale(i):

2870

if maxtotal <= graphwidth:

2872

if maxtotal <= graphwidth:

2871

return i

2873

return i

2872

# If diffstat runs out of room it doesn't print anything,

2874

# If diffstat runs out of room it doesn't print anything,

2873

# which isn't very useful, so always print at least one + or -

2875

# which isn't very useful, so always print at least one + or -

2874

# if there were at least some changes.

2876

# if there were at least some changes.

2875

return max(i * graphwidth // maxtotal, int(bool(i)))

2877

return max(i * graphwidth // maxtotal, int(bool(i)))

2876

2878

2877

for filename, adds, removes, isbinary in stats:

2879

for filename, adds, removes, isbinary in stats:

2878

if isbinary:

2880

if isbinary:

2879

count = 'Bin'

2881

count = 'Bin'

2880

else:

2882

else:

2881

count = '%d' % (adds + removes)

2883

count = '%d' % (adds + removes)

2882

pluses = '+' * scale(adds)

2884

pluses = '+' * scale(adds)

2883

minuses = '-' * scale(removes)

2885

minuses = '-' * scale(removes)

2884

output.append(' %s%s | %*s %s%s\n' %

2886

output.append(' %s%s | %*s %s%s\n' %

2885

(filename, ' ' * (maxname - encoding.colwidth(filename)),

2887

(filename, ' ' * (maxname - encoding.colwidth(filename)),

2886

countwidth, count, pluses, minuses))

2888

countwidth, count, pluses, minuses))

2887

2889

2888

if stats:

2890

if stats:

2889

output.append(_(' %d files changed, %d insertions(+), '

2891

output.append(_(' %d files changed, %d insertions(+), '

2890

'%d deletions(-)\n')

2892

'%d deletions(-)\n')

2891

% (len(stats), totaladds, totalremoves))

2893

% (len(stats), totaladds, totalremoves))

2892

2894

2893

return ''.join(output)

2895

return ''.join(output)

2894

2896

2895

def diffstatui(*args, **kw):

2897

def diffstatui(*args, **kw):

2896

'''like diffstat(), but yields 2-tuples of (output, label) for

2898

'''like diffstat(), but yields 2-tuples of (output, label) for

2897

ui.write()

2899

ui.write()

2898

'''

2900

'''

2899

2901

2900

for line in diffstat(*args, **kw).splitlines():

2902

for line in diffstat(*args, **kw).splitlines():

2901

if line and line[-1] in '+-':

2903

if line and line[-1] in '+-':

2902

name, graph = line.rsplit(' ', 1)

2904

name, graph = line.rsplit(' ', 1)

2903

yield (name + ' ', '')

2905

yield (name + ' ', '')

2904

m = re.search(br'\++', graph)

2906

m = re.search(br'\++', graph)

2905

if m:

2907

if m:

2906

yield (m.group(0), 'diffstat.inserted')

2908

yield (m.group(0), 'diffstat.inserted')

2907

m = re.search(br'-+', graph)

2909

m = re.search(br'-+', graph)

2908

if m:

2910

if m:

2909

yield (m.group(0), 'diffstat.deleted')

2911

yield (m.group(0), 'diffstat.deleted')

2910

else:

2912

else:

2911

yield (line, '')

2913

yield (line, '')

2912

yield ('\n', '')

2914

yield ('\n', '')

	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

             test-abort-checkin.t
             test-add.t
             test-addremove-similar.t
             test-addremove.t
             test-amend-subrepo.t
             test-amend.t
             test-ancestor.py
             test-annotate.py
             test-annotate.t
             test-archive-symlinks.t
             test-atomictempfile.py
             test-audit-path.t
             test-audit-subrepo.t
             test-automv.t
             test-backout.t
             test-backwards-remove.t
             test-basic.t
             test-bheads.t
             test-bisect.t
             test-bisect2.t
             test-bisect3.t
             test-blackbox.t
             test-bookmarks-current.t
             test-bookmarks-merge.t
             test-bookmarks-rebase.t
             test-bookmarks-strip.t
             test-bookmarks.t
             test-branch-change.t
             test-branch-option.t
             test-branch-tag-confict.t
             test-branches.t
             test-bundle-phases.t
             test-bundle-type.t
             test-bundle-vs-outgoing.t
             test-bundle2-multiple-changegroups.t
             test-cappedreader.py
             test-casecollision.t
             test-cat.t
             test-censor.t
             test-changelog-exec.t
             test-check-commit.t
             test-check-execute.t
             test-check-module-imports.t
             test-check-pyflakes.t
             test-check-pylint.t
             test-check-shbang.t
             test-children.t
             test-clone-pull-corruption.t
             test-clone-r.t
             test-clone-update-order.t
             test-command-template.t
             test-commit-amend.t
             test-commit-interactive.t
             test-commit-multiple.t
             test-commit-unresolved.t
             test-commit.t
             test-committer.t
             test-completion.t
             test-config-env.py
             test-config.t
             test-conflict.t
             test-confused-revert.t
             test-contrib-check-code.t
             test-contrib-check-commit.t
             test-convert-authormap.t
             test-convert-clonebranches.t
             test-convert-datesort.t
             test-convert-filemap.t
             test-convert-hg-sink.t
             test-convert-hg-source.t
             test-convert-hg-startrev.t
             test-copy-move-merge.t
             test-copy.t
             test-copytrace-heuristics.t
             test-debugbuilddag.t
             test-debugbundle.t
             test-debugextensions.t
             test-debugindexdot.t
             test-debugrename.t
             test-default-push.t
             test-diff-binary-file.t
             test-diff-change.t
             test-diff-copy-depth.t
             test-diff-hashes.t
             test-diff-ignore-whitespace.t
             test-diff-indent-heuristic.t
             test-diff-issue2761.t
             test-diff-newlines.t
             test-diff-reverse.t
             test-diff-subdir.t
             test-diff-unified.t
             test-diff-upgrade.t
             test-diffdir.t
             test-directaccess.t
             test-dirstate-backup.t
             test-dirstate-nonnormalset.t
             test-doctest.py
             test-double-merge.t
             test-drawdag.t
             test-duplicateoptions.py
             test-editor-filename.t
             test-empty-dir.t
             test-empty-file.t
             test-empty-group.t
             test-empty.t
             test-encode.t
             test-encoding-func.py
             test-encoding.t
             test-eol-add.t
             test-eol-clone.t
             test-eol-hook.t
             test-eol-tag.t
             test-eol-update.t
             test-excessive-merge.t
             test-exchange-obsmarkers-case-A1.t
             test-exchange-obsmarkers-case-A2.t
             test-exchange-obsmarkers-case-A3.t
             test-exchange-obsmarkers-case-A4.t
             test-exchange-obsmarkers-case-A5.t
             test-exchange-obsmarkers-case-A6.t
             test-exchange-obsmarkers-case-A7.t
             test-exchange-obsmarkers-case-B1.t
             test-exchange-obsmarkers-case-B2.t
             test-exchange-obsmarkers-case-B3.t
             test-exchange-obsmarkers-case-B4.t
             test-exchange-obsmarkers-case-B5.t
             test-exchange-obsmarkers-case-B6.t
             test-exchange-obsmarkers-case-B7.t
             test-exchange-obsmarkers-case-C1.t
             test-exchange-obsmarkers-case-C2.t
             test-exchange-obsmarkers-case-C3.t
             test-exchange-obsmarkers-case-C4.t
             test-exchange-obsmarkers-case-D1.t
             test-exchange-obsmarkers-case-D2.t
             test-exchange-obsmarkers-case-D3.t
             test-exchange-obsmarkers-case-D4.t
             test-execute-bit.t
             test-extdiff.t
             test-extra-filelog-entry.t
             test-filebranch.t
             test-fileset-generated.t
             test-flags.t
             test-generaldelta.t
             test-getbundle.t
             test-git-export.t
             test-glog-topological.t
             test-gpg.t
             test-graft.t
             test-hghave.t
             test-hgignore.t
             test-hgk.t
             test-hgweb-bundle.t
             test-hgweb-descend-empties.t
             test-hgweb-removed.t
             test-histedit-arguments.t
             test-histedit-base.t
             test-histedit-bookmark-motion.t
             test-histedit-commute.t
             test-histedit-drop.t
             test-histedit-edit.t
             test-histedit-fold-non-commute.t
             test-histedit-fold.t
             test-histedit-no-change.t
             test-histedit-non-commute-abort.t
             test-histedit-non-commute.t
             test-histedit-obsolete.t
             test-histedit-outgoing.t
             test-histedit-templates.t
             test-http-branchmap.t
             test-http-bundle1.t
             test-http-clone-r.t
             test-identify.t
             test-import-unknown.t
+            test-import.t
             test-imports-checker.t
             test-inherit-mode.t
             test-issue1089.t
             test-issue1102.t
             test-issue1175.t
             test-issue1306.t
             test-issue1438.t
             test-issue1502.t
             test-issue1802.t
             test-issue1877.t
             test-issue1993.t
             test-issue2137.t
             test-issue3084.t
             test-issue4074.t
             test-issue522.t
             test-issue586.t
             test-issue612.t
             test-issue619.t
             test-issue660.t
             test-issue672.t
             test-issue842.t
             test-journal-exists.t
             test-journal-share.t
             test-journal.t
             test-largefiles-cache.t
             test-largefiles-misc.t
             test-largefiles-small-disk.t
             test-largefiles-update.t
             test-lfs-largefiles.t
             test-locate.t
             test-lock-badness.t
             test-log-linerange.t
             test-log.t
             test-logexchange.t
             test-lrucachedict.py
             test-mactext.t
             test-mailmap.t
             test-manifest-merging.t
             test-manifest.py
             test-manifest.t
             test-match.py
             test-mdiff.py
             test-merge-changedelete.t
             test-merge-closedheads.t
             test-merge-commit.t
             test-merge-criss-cross.t
             test-merge-default.t
             test-merge-force.t
             test-merge-halt.t
             test-merge-internal-tools-pattern.t
             test-merge-local.t
             test-merge-remove.t
             test-merge-revert.t
             test-merge-revert2.t
             test-merge-subrepos.t
             test-merge-symlinks.t
             test-merge-tools.t
             test-merge-types.t
             test-merge1.t
             test-merge10.t
             test-merge2.t
             test-merge4.t
             test-merge5.t
             test-merge6.t
             test-merge7.t
             test-merge8.t
             test-merge9.t
             test-mq-git.t
             test-mq-header-date.t
             test-mq-header-from.t
             test-mq-pull-from-bundle.t
             test-mq-qdiff.t
             test-mq-qfold.t
             test-mq-qgoto.t
             test-mq-qimport-fail-cleanup.t
             test-mq-qpush-exact.t
             test-mq-qqueue.t
             test-mq-qrefresh-interactive.t
             test-mq-qrefresh-replace-log-message.t
             test-mq-qrefresh.t
             test-mq-qrename.t
             test-mq-qsave.t
             test-mq-safety.t
             test-mq-subrepo.t
             test-mq-symlinks.t
             test-mv-cp-st-diff.t
             test-narrow-archive.t
             test-narrow-clone-no-ellipsis.t
             test-narrow-clone-nonlinear.t
             test-narrow-clone.t
             test-narrow-commit.t
             test-narrow-copies.t
             test-narrow-debugcommands.t
             test-narrow-debugrebuilddirstate.t
             test-narrow-exchange-merges.t
             test-narrow-exchange.t
             test-narrow-expanddirstate.t
             test-narrow-merge.t
             test-narrow-patch.t
             test-narrow-patterns.t
             test-narrow-pull.t
             test-narrow-rebase.t
             test-narrow-shallow-merges.t
             test-narrow-shallow.t
             test-narrow-strip.t
             test-narrow-update.t
             test-nested-repo.t
             test-newbranch.t
             test-obshistory.t
             test-obsmarker-template.t
             test-obsmarkers-effectflag.t
             test-obsolete-bundle-strip.t
             test-obsolete-changeset-exchange.t
             test-obsolete-checkheads.t
             test-obsolete-distributed.t
             test-obsolete-tag-cache.t
             test-parents.t
             test-pathconflicts-merge.t
             test-pathconflicts-update.t
             test-pending.t
             test-permissions.t
             test-phases.t
             test-pull-branch.t
             test-pull-http.t
             test-pull-permission.t
             test-pull-pull-corruption.t
             test-pull-r.t
             test-pull-update.t
             test-purge.t
             test-push-checkheads-partial-C1.t
             test-push-checkheads-partial-C2.t
             test-push-checkheads-partial-C3.t
             test-push-checkheads-partial-C4.t
             test-push-checkheads-pruned-B1.t
             test-push-checkheads-pruned-B2.t
             test-push-checkheads-pruned-B3.t
             test-push-checkheads-pruned-B4.t
             test-push-checkheads-pruned-B5.t
             test-push-checkheads-pruned-B6.t
             test-push-checkheads-pruned-B7.t
             test-push-checkheads-pruned-B8.t
             test-push-checkheads-superceed-A1.t
             test-push-checkheads-superceed-A2.t
             test-push-checkheads-superceed-A3.t
             test-push-checkheads-superceed-A4.t
             test-push-checkheads-superceed-A5.t
             test-push-checkheads-superceed-A6.t
             test-push-checkheads-superceed-A7.t
             test-push-checkheads-superceed-A8.t
             test-push-checkheads-unpushed-D1.t
             test-push-checkheads-unpushed-D2.t
             test-push-checkheads-unpushed-D3.t
             test-push-checkheads-unpushed-D4.t
             test-push-checkheads-unpushed-D5.t
             test-push-checkheads-unpushed-D6.t
             test-push-checkheads-unpushed-D7.t
             test-push-http.t
             test-push-warn.t
             test-pushvars.t
             test-rebase-abort.t
             test-rebase-base-flag.t
             test-rebase-bookmarks.t
             test-rebase-brute-force.t
             test-rebase-cache.t
             test-rebase-check-restore.t
             test-rebase-collapse.t
             test-rebase-conflicts.t
             test-rebase-dest.t
             test-rebase-detach.t
             test-rebase-emptycommit.t
             test-rebase-inmemory.t
             test-rebase-interruptions.t
             test-rebase-issue-noparam-single-rev.t
             test-rebase-legacy.t
             test-rebase-mq-skip.t
             test-rebase-named-branches.t
             test-rebase-newancestor.t
             test-rebase-obsolete.t
             test-rebase-parameters.t
             test-rebase-partial.t
             test-rebase-pull.t
             test-rebase-rename.t
             test-rebase-scenario-global.t
             test-rebase-templates.t
             test-rebase-transaction.t
             test-record.t
             test-relink.t
             test-remove.t
             test-rename-after-merge.t
             test-rename-dir-merge.t
             test-rename-merge1.t
             test-rename.t
             test-repair-strip.t
             test-repo-compengines.t
             test-resolve.t
             test-revert-flags.t
             test-revert-unknown.t
             test-revlog-ancestry.py
             test-revlog-group-emptyiter.t
             test-revlog-mmapindex.t
             test-revlog-packentry.t
             test-revset-dirstate-parents.t
             test-revset-outgoing.t
             test-rollback.t
             test-run-tests.py
             test-schemes.t
             test-serve.t
             test-share.t
             test-show-stack.t
             test-show-work.t
             test-show.t
             test-simple-update.t
             test-single-head.t
             test-sparse-clear.t
             test-sparse-merges.t
             test-sparse-requirement.t
             test-sparse-verbose-json.t
             test-ssh-clone-r.t
             test-ssh-proto.t
             test-sshserver.py
             test-stack.t
             test-status-rev.t
             test-status-terse.t
             test-strip-cross.t
             test-strip.t
             test-subrepo-deep-nested-change.t
             test-subrepo.t
             test-symlinks.t
             test-tag.t
             test-tags.t
             test-template-engine.t
             test-treemanifest.t
             test-unamend.t
             test-uncommit.t
             test-unified-test.t
             test-unrelated-pull.t
             test-up-local-change.t
             test-update-branches.t
             test-update-dest.t
             test-update-issue1456.t
             test-update-names.t
             test-update-reverse.t
             test-upgrade-repo.t
             test-url-rev.t
             test-username-newline.t
             test-verify.t
             test-websub.t
             test-win32text.t
             test-xdg.t

             # patch.py - patch file parsing routines
             #
             # Copyright 2006 Brendan Cully <brendan@kublai.com>
             # Copyright 2007 Chris Mason <chris.mason@oracle.com>
             #
             # This software may be used and distributed according to the terms of the
             # GNU General Public License version 2 or any later version.
             from __future__ import absolute_import, print_function
             import collections
             import copy
             import difflib
             import email
             import errno
             import hashlib
             import os
             import posixpath
             import re
             import shutil
             import tempfile
             import zlib
             from .i18n import _
             from .node import (
                 hex,
                 short,
             )
             from . import (
                 copies,
                 encoding,
                 error,
                 mail,
                 mdiff,
                 pathutil,
                 policy,
                 pycompat,
                 scmutil,
                 similar,
                 util,
                 vfs as vfsmod,
             )
             from .utils import (
                 dateutil,
                 procutil,
                 stringutil,
             )
             diffhelpers = policy.importmod(r'diffhelpers')
             stringio = util.stringio
             gitre = re.compile(br'diff --git a/(.*) b/(.*)')
             tabsplitter = re.compile(br'(\t+|[^\t]+)')
             _nonwordre = re.compile(br'([^a-zA-Z0-9_\x80-\xff])')
             PatchError = error.PatchError
             # public functions
             def split(stream):
                 '''return an iterator of individual patches from a stream'''
                 def isheader(line, inheader):
-                    if inheader and line[0] in (' ', '\t'):
+                    if inheader and line.startswith((' ', '\t')):
                         # continuation
                         return True
-                    if line[0] in (' ', '-', '+'):
+                    if line.startswith((' ', '-', '+')):
                         # diff line - don't check for header pattern in there
                         return False
                     l = line.split(': ', 1)
                     return len(l) == 2 and ' ' not in l[0]
                 def chunk(lines):
                     return stringio(''.join(lines))
                 def hgsplit(stream, cur):
                     inheader = True
                     for line in stream:
                         if not line.strip():
                             inheader = False
                         if not inheader and line.startswith('# HG changeset patch'):
                             yield chunk(cur)
                             cur = []
                             inheader = True
                         cur.append(line)
                     if cur:
                         yield chunk(cur)
                 def mboxsplit(stream, cur):
                     for line in stream:
                         if line.startswith('From '):
                             for c in split(chunk(cur[1:])):
                                 yield c
                             cur = []
                         cur.append(line)
                     if cur:
                         for c in split(chunk(cur[1:])):
                             yield c
                 def mimesplit(stream, cur):
                     def msgfp(m):
                         fp = stringio()
                         g = email.Generator.Generator(fp, mangle_from_=False)
                         g.flatten(m)
                         fp.seek(0)
                         return fp
                     for line in stream:
                         cur.append(line)
                     c = chunk(cur)
                     m = pycompat.emailparser().parse(c)
                     if not m.is_multipart():
                         yield msgfp(m)
                     else:
                         ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
                         for part in m.walk():
                             ct = part.get_content_type()
                             if ct not in ok_types:
                                 continue
                             yield msgfp(part)
                 def headersplit(stream, cur):
                     inheader = False
                     for line in stream:
                         if not inheader and isheader(line, inheader):
                             yield chunk(cur)
                             cur = []
                             inheader = True
                         if inheader and not isheader(line, inheader):
                             inheader = False
                         cur.append(line)
                     if cur:
                         yield chunk(cur)
                 def remainder(cur):
                     yield chunk(cur)
                 class fiter(object):
                     def __init__(self, fp):
                         self.fp = fp
                     def __iter__(self):
                         return self
                     def next(self):
                         l = self.fp.readline()
                         if not l:
                             raise StopIteration
                         return l
                     __next__ = next
                 inheader = False
                 cur = []
                 mimeheaders = ['content-type']
                 if not util.safehasattr(stream, 'next'):
                     # http responses, for example, have readline but not next
                     stream = fiter(stream)
                 for line in stream:
                     cur.append(line)
                     if line.startswith('# HG changeset patch'):
                         return hgsplit(stream, cur)
                     elif line.startswith('From '):
                         return mboxsplit(stream, cur)
                     elif isheader(line, inheader):
                         inheader = True
                         if line.split(':', 1)[0].lower() in mimeheaders:
                             # let email parser handle this
                             return mimesplit(stream, cur)
                     elif line.startswith('--- ') and inheader:
                         # No evil headers seen by diff start, split by hand
                         return headersplit(stream, cur)
                     # Not enough info, keep reading
                 # if we are here, we have a very plain patch
                 return remainder(cur)
             ## Some facility for extensible patch parsing:
             # list of pairs ("header to match", "data key")
             patchheadermap = [('Date', 'date'),
                               ('Branch', 'branch'),
                               ('Node ID', 'nodeid'),
                              ]
             def extract(ui, fileobj):
                 '''extract patch from data read from fileobj.
                 patch can be a normal patch or contained in an email message.
                 return a dictionary. Standard keys are:
                   - filename,
                   - message,
                   - user,
                   - date,
                   - branch,
                   - node,
                   - p1,
                   - p2.
                 Any item can be missing from the dictionary. If filename is missing,
                 fileobj did not contain a patch. Caller must unlink filename when done.'''
                 # attempt to detect the start of a patch
                 # (this heuristic is borrowed from quilt)
                 diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
                                     br'retrieving revision [0-9]+(\.[0-9]+)*$|'
                                     br'---[ \t].*?^\+\+\+[ \t]|'
                                     br'\*\*\*[ \t].*?^---[ \t])',
                                     re.MULTILINE | re.DOTALL)
                 data = {}
                 fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
                 tmpfp = os.fdopen(fd, r'wb')
                 try:
                     msg = pycompat.emailparser().parse(fileobj)
                     subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject'])
                     data['user'] = msg[r'From'] and mail.headdecode(msg[r'From'])
                     if not subject and not data['user']:
                         # Not an email, restore parsed headers if any
                         subject = '\n'.join(': '.join(map(encoding.strtolocal, h))
                                             for h in msg.items()) + '\n'
                     # should try to parse msg['Date']
                     parents = []
                     if subject:
                         if subject.startswith('[PATCH'):
                             pend = subject.find(']')
                             if pend >= 0:
                                 subject = subject[pend + 1:].lstrip()
                         subject = re.sub(br'\n[ \t]+', ' ', subject)
                         ui.debug('Subject: %s\n' % subject)
                     if data['user']:
                         ui.debug('From: %s\n' % data['user'])
                     diffs_seen = 0
                     ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
                     message = ''
                     for part in msg.walk():
                         content_type = pycompat.bytestr(part.get_content_type())
                         ui.debug('Content-Type: %s\n' % content_type)
                         if content_type not in ok_types:
                             continue
                         payload = part.get_payload(decode=True)
                         m = diffre.search(payload)
                         if m:
                             hgpatch = False
                             hgpatchheader = False
                             ignoretext = False
                             ui.debug('found patch at byte %d\n' % m.start(0))
                             diffs_seen += 1
                             cfp = stringio()
                             for line in payload[:m.start(0)].splitlines():
                                 if line.startswith('# HG changeset patch') and not hgpatch:
                                     ui.debug('patch generated by hg export\n')
                                     hgpatch = True
                                     hgpatchheader = True
                                     # drop earlier commit message content
                                     cfp.seek(0)
                                     cfp.truncate()
                                     subject = None
                                 elif hgpatchheader:
                                     if line.startswith('# User '):
                                         data['user'] = line[7:]
                                         ui.debug('From: %s\n' % data['user'])
                                     elif line.startswith("# Parent "):
                                         parents.append(line[9:].lstrip())
                                     elif line.startswith("# "):
                                         for header, key in patchheadermap:
                                             prefix = '# %s ' % header
                                             if line.startswith(prefix):
                                                 data[key] = line[len(prefix):]
                                     else:
                                         hgpatchheader = False
                                 elif line == '---':
                                     ignoretext = True
                                 if not hgpatchheader and not ignoretext:
                                     cfp.write(line)
                                     cfp.write('\n')
                             message = cfp.getvalue()
                             if tmpfp:
                                 tmpfp.write(payload)
                                 if not payload.endswith('\n'):
                                     tmpfp.write('\n')
                         elif not diffs_seen and message and content_type == 'text/plain':
                             message += '\n' + payload
                 except: # re-raises
                     tmpfp.close()
                     os.unlink(tmpname)
                     raise
                 if subject and not message.startswith(subject):
                     message = '%s\n%s' % (subject, message)
                 data['message'] = message
                 tmpfp.close()
                 if parents:
                     data['p1'] = parents.pop(0)
                     if parents:
                         data['p2'] = parents.pop(0)
                 if diffs_seen:
                     data['filename'] = tmpname
                 else:
                     os.unlink(tmpname)
                 return data
             class patchmeta(object):
                 """Patched file metadata
                 'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
                 or COPY.  'path' is patched file path. 'oldpath' is set to the
                 origin file when 'op' is either COPY or RENAME, None otherwise. If
                 file mode is changed, 'mode' is a tuple (islink, isexec) where
                 'islink' is True if the file is a symlink and 'isexec' is True if
                 the file is executable. Otherwise, 'mode' is None.
                 """
                 def __init__(self, path):
                     self.path = path
                     self.oldpath = None
                     self.mode = None
                     self.op = 'MODIFY'
                     self.binary = False
                 def setmode(self, mode):
                     islink = mode & 0o20000
                     isexec = mode & 0o100
                     self.mode = (islink, isexec)
                 def copy(self):
                     other = patchmeta(self.path)
                     other.oldpath = self.oldpath
                     other.mode = self.mode
                     other.op = self.op
                     other.binary = self.binary
                     return other
                 def _ispatchinga(self, afile):
                     if afile == '/dev/null':
                         return self.op == 'ADD'
                     return afile == 'a/' + (self.oldpath or self.path)
                 def _ispatchingb(self, bfile):
                     if bfile == '/dev/null':
                         return self.op == 'DELETE'
                     return bfile == 'b/' + self.path
                 def ispatching(self, afile, bfile):
                     return self._ispatchinga(afile) and self._ispatchingb(bfile)
                 def __repr__(self):
                     return "<patchmeta %s %r>" % (self.op, self.path)
             def readgitpatch(lr):
                 """extract git-style metadata about patches from <patchname>"""
                 # Filter patch for git information
                 gp = None
                 gitpatches = []
                 for line in lr:
                     line = line.rstrip(' \r\n')
                     if line.startswith('diff --git a/'):
                         m = gitre.match(line)
                         if m:
                             if gp:
                                 gitpatches.append(gp)
                             dst = m.group(2)
                             gp = patchmeta(dst)
                     elif gp:
                         if line.startswith('--- '):
                             gitpatches.append(gp)
                             gp = None
                             continue
                         if line.startswith('rename from '):
                             gp.op = 'RENAME'
                             gp.oldpath = line[12:]
                         elif line.startswith('rename to '):
                             gp.path = line[10:]
                         elif line.startswith('copy from '):
                             gp.op = 'COPY'
                             gp.oldpath = line[10:]
                         elif line.startswith('copy to '):
                             gp.path = line[8:]
                         elif line.startswith('deleted file'):
                             gp.op = 'DELETE'
                         elif line.startswith('new file mode '):
                             gp.op = 'ADD'
                             gp.setmode(int(line[-6:], 8))
                         elif line.startswith('new mode '):
                             gp.setmode(int(line[-6:], 8))
                         elif line.startswith('GIT binary patch'):
                             gp.binary = True
                 if gp:
                     gitpatches.append(gp)
                 return gitpatches
             class linereader(object):
                 # simple class to allow pushing lines back into the input stream
                 def __init__(self, fp):
                     self.fp = fp
                     self.buf = []
                 def push(self, line):
                     if line is not None:
                         self.buf.append(line)
                 def readline(self):
                     if self.buf:
                         l = self.buf[0]
                         del self.buf[0]
                         return l
                     return self.fp.readline()
                 def __iter__(self):
                     return iter(self.readline, '')
             class abstractbackend(object):
                 def __init__(self, ui):
                     self.ui = ui
                 def getfile(self, fname):
                     """Return target file data and flags as a (data, (islink,
                     isexec)) tuple. Data is None if file is missing/deleted.
                     """
                     raise NotImplementedError
                 def setfile(self, fname, data, mode, copysource):
                     """Write data to target file fname and set its mode. mode is a
                     (islink, isexec) tuple. If data is None, the file content should
                     be left unchanged. If the file is modified after being copied,
                     copysource is set to the original file name.
                     """
                     raise NotImplementedError
                 def unlink(self, fname):
                     """Unlink target file."""
                     raise NotImplementedError
                 def writerej(self, fname, failed, total, lines):
                     """Write rejected lines for fname. total is the number of hunks
                     which failed to apply and total the total number of hunks for this
                     files.
                     """
                 def exists(self, fname):
                     raise NotImplementedError
                 def close(self):
                     raise NotImplementedError
             class fsbackend(abstractbackend):
                 def __init__(self, ui, basedir):
                     super(fsbackend, self).__init__(ui)
                     self.opener = vfsmod.vfs(basedir)
                 def getfile(self, fname):
                     if self.opener.islink(fname):
                         return (self.opener.readlink(fname), (True, False))
                     isexec = False
                     try:
                         isexec = self.opener.lstat(fname).st_mode & 0o100 != 0
                     except OSError as e:
                         if e.errno != errno.ENOENT:
                             raise
                     try:
                         return (self.opener.read(fname), (False, isexec))
                     except IOError as e:
                         if e.errno != errno.ENOENT:
                             raise
                         return None, None
                 def setfile(self, fname, data, mode, copysource):
                     islink, isexec = mode
                     if data is None:
                         self.opener.setflags(fname, islink, isexec)
                         return
                     if islink:
                         self.opener.symlink(data, fname)
                     else:
                         self.opener.write(fname, data)
                         if isexec:
                             self.opener.setflags(fname, False, True)
                 def unlink(self, fname):
                     self.opener.unlinkpath(fname, ignoremissing=True)
                 def writerej(self, fname, failed, total, lines):
                     fname = fname + ".rej"
                     self.ui.warn(
                         _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
                         (failed, total, fname))
                     fp = self.opener(fname, 'w')
                     fp.writelines(lines)
                     fp.close()
                 def exists(self, fname):
                     return self.opener.lexists(fname)
             class workingbackend(fsbackend):
                 def __init__(self, ui, repo, similarity):
                     super(workingbackend, self).__init__(ui, repo.root)
                     self.repo = repo
                     self.similarity = similarity
                     self.removed = set()
                     self.changed = set()
                     self.copied = []
                 def _checkknown(self, fname):
                     if self.repo.dirstate[fname] == '?' and self.exists(fname):
                         raise PatchError(_('cannot patch %s: file is not tracked') % fname)
                 def setfile(self, fname, data, mode, copysource):
                     self._checkknown(fname)
                     super(workingbackend, self).setfile(fname, data, mode, copysource)
                     if copysource is not None:
                         self.copied.append((copysource, fname))
                     self.changed.add(fname)
                 def unlink(self, fname):
                     self._checkknown(fname)
                     super(workingbackend, self).unlink(fname)
                     self.removed.add(fname)
                     self.changed.add(fname)
                 def close(self):
                     wctx = self.repo[None]
                     changed = set(self.changed)
                     for src, dst in self.copied:
                         scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
                     if self.removed:
                         wctx.forget(sorted(self.removed))
                         for f in self.removed:
                             if f not in self.repo.dirstate:
                                 # File was deleted and no longer belongs to the
                                 # dirstate, it was probably marked added then
                                 # deleted, and should not be considered by
                                 # marktouched().
                                 changed.discard(f)
                     if changed:
                         scmutil.marktouched(self.repo, changed, self.similarity)
                     return sorted(self.changed)
             class filestore(object):
                 def __init__(self, maxsize=None):
                     self.opener = None
                     self.files = {}
                     self.created = 0
                     self.maxsize = maxsize
                     if self.maxsize is None:
                         self.maxsize = 4*(2**20)
                     self.size = 0
                     self.data = {}
                 def setfile(self, fname, data, mode, copied=None):
                     if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
                         self.data[fname] = (data, mode, copied)
                         self.size += len(data)
                     else:
                         if self.opener is None:
                             root = tempfile.mkdtemp(prefix='hg-patch-')
                             self.opener = vfsmod.vfs(root)
                         # Avoid filename issues with these simple names
                         fn = '%d' % self.created
                         self.opener.write(fn, data)
                         self.created += 1
                         self.files[fname] = (fn, mode, copied)
                 def getfile(self, fname):
                     if fname in self.data:
                         return self.data[fname]
                     if not self.opener or fname not in self.files:
                         return None, None, None
                     fn, mode, copied = self.files[fname]
                     return self.opener.read(fn), mode, copied
                 def close(self):
                     if self.opener:
                         shutil.rmtree(self.opener.base)
             class repobackend(abstractbackend):
                 def __init__(self, ui, repo, ctx, store):
                     super(repobackend, self).__init__(ui)
                     self.repo = repo
                     self.ctx = ctx
                     self.store = store
                     self.changed = set()
                     self.removed = set()
                     self.copied = {}
                 def _checkknown(self, fname):
                     if fname not in self.ctx:
                         raise PatchError(_('cannot patch %s: file is not tracked') % fname)
                 def getfile(self, fname):
                     try:
                         fctx = self.ctx[fname]
                     except error.LookupError:
                         return None, None
                     flags = fctx.flags()
                     return fctx.data(), ('l' in flags, 'x' in flags)
                 def setfile(self, fname, data, mode, copysource):
                     if copysource:
                         self._checkknown(copysource)
                     if data is None:
                         data = self.ctx[fname].data()
                     self.store.setfile(fname, data, mode, copysource)
                     self.changed.add(fname)
                     if copysource:
                         self.copied[fname] = copysource
                 def unlink(self, fname):
                     self._checkknown(fname)
                     self.removed.add(fname)
                 def exists(self, fname):
                     return fname in self.ctx
                 def close(self):
                     return self.changed | self.removed
             # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
             unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
             contextdesc = re.compile('(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')
             eolmodes = ['strict', 'crlf', 'lf', 'auto']
             class patchfile(object):
                 def __init__(self, ui, gp, backend, store, eolmode='strict'):
                     self.fname = gp.path
                     self.eolmode = eolmode
                     self.eol = None
                     self.backend = backend
                     self.ui = ui
                     self.lines = []
                     self.exists = False
                     self.missing = True
                     self.mode = gp.mode
                     self.copysource = gp.oldpath
                     self.create = gp.op in ('ADD', 'COPY', 'RENAME')
                     self.remove = gp.op == 'DELETE'
                     if self.copysource is None:
                         data, mode = backend.getfile(self.fname)
                     else:
                         data, mode = store.getfile(self.copysource)[:2]
                     if data is not None:
                         self.exists = self.copysource is None or backend.exists(self.fname)
                         self.missing = False
                         if data:
                             self.lines = mdiff.splitnewlines(data)
                         if self.mode is None:
                             self.mode = mode
                         if self.lines:
                             # Normalize line endings
                             if self.lines[0].endswith('\r\n'):
                                 self.eol = '\r\n'
                             elif self.lines[0].endswith('\n'):
                                 self.eol = '\n'
                             if eolmode != 'strict':
                                 nlines = []
                                 for l in self.lines:
                                     if l.endswith('\r\n'):
                                         l = l[:-2] + '\n'
                                     nlines.append(l)
                                 self.lines = nlines
                     else:
                         if self.create:
                             self.missing = False
                         if self.mode is None:
                             self.mode = (False, False)
                     if self.missing:
                         self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
                         self.ui.warn(_("(use '--prefix' to apply patch relative to the "
                                        "current directory)\n"))
                     self.hash = {}
                     self.dirty = 0
                     self.offset = 0
                     self.skew = 0
                     self.rej = []
                     self.fileprinted = False
                     self.printfile(False)
                     self.hunks = 0
                 def writelines(self, fname, lines, mode):
                     if self.eolmode == 'auto':
                         eol = self.eol
                     elif self.eolmode == 'crlf':
                         eol = '\r\n'
                     else:
                         eol = '\n'
                     if self.eolmode != 'strict' and eol and eol != '\n':
                         rawlines = []
                         for l in lines:
                             if l and l[-1] == '\n':
                                 l = l[:-1] + eol
                             rawlines.append(l)
                         lines = rawlines
                     self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
                 def printfile(self, warn):
                     if self.fileprinted:
                         return
                     if warn or self.ui.verbose:
                         self.fileprinted = True
                     s = _("patching file %s\n") % self.fname
                     if warn:
                         self.ui.warn(s)
                     else:
                         self.ui.note(s)
                 def findlines(self, l, linenum):
                     # looks through the hash and finds candidate lines.  The
                     # result is a list of line numbers sorted based on distance
                     # from linenum
                     cand = self.hash.get(l, [])
                     if len(cand) > 1:
                         # resort our list of potentials forward then back.
                         cand.sort(key=lambda x: abs(x - linenum))
                     return cand
                 def write_rej(self):
                     # our rejects are a little different from patch(1).  This always
                     # creates rejects in the same form as the original patch.  A file
                     # header is inserted so that you can run the reject through patch again
                     # without having to type the filename.
                     if not self.rej:
                         return
                     base = os.path.basename(self.fname)
                     lines = ["--- %s\n+++ %s\n" % (base, base)]
                     for x in self.rej:
                         for l in x.hunk:
                             lines.append(l)
                             if l[-1:] != '\n':
                                 lines.append("\n\ No newline at end of file\n")
                     self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
                 def apply(self, h):
                     if not h.complete():
                         raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
                                         (h.number, h.desc, len(h.a), h.lena, len(h.b),
                                         h.lenb))
                     self.hunks += 1
                     if self.missing:
                         self.rej.append(h)
                         return -1
                     if self.exists and self.create:
                         if self.copysource:
                             self.ui.warn(_("cannot create %s: destination already "
                                            "exists\n") % self.fname)
                         else:
                             self.ui.warn(_("file %s already exists\n") % self.fname)
                         self.rej.append(h)
                         return -1
                     if isinstance(h, binhunk):
                         if self.remove:
                             self.backend.unlink(self.fname)
                         else:
                             l = h.new(self.lines)
                             self.lines[:] = l
                             self.offset += len(l)
                             self.dirty = True
                         return 0
                     horig = h
                     if (self.eolmode in ('crlf', 'lf')
                         or self.eolmode == 'auto' and self.eol):
                         # If new eols are going to be normalized, then normalize
                         # hunk data before patching. Otherwise, preserve input
                         # line-endings.
                         h = h.getnormalized()
                     # fast case first, no offsets, no fuzz
                     old, oldstart, new, newstart = h.fuzzit(0, False)
                     oldstart += self.offset
                     orig_start = oldstart
                     # if there's skew we want to emit the "(offset %d lines)" even
                     # when the hunk cleanly applies at start + skew, so skip the
                     # fast case code
                     if (self.skew == 0 and
                         diffhelpers.testhunk(old, self.lines, oldstart) == 0):
                         if self.remove:
                             self.backend.unlink(self.fname)
                         else:
                             self.lines[oldstart:oldstart + len(old)] = new
                             self.offset += len(new) - len(old)
                             self.dirty = True
                         return 0
                     # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
                     self.hash = {}
                     for x, s in enumerate(self.lines):
                         self.hash.setdefault(s, []).append(x)
                     for fuzzlen in xrange(self.ui.configint("patch", "fuzz") + 1):
                         for toponly in [True, False]:
                             old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)
                             oldstart = oldstart + self.offset + self.skew
                             oldstart = min(oldstart, len(self.lines))
                             if old:
                                 cand = self.findlines(old[0][1:], oldstart)
                             else:
                                 # Only adding lines with no or fuzzed context, just
                                 # take the skew in account
                                 cand = [oldstart]
                             for l in cand:
                                 if not old or diffhelpers.testhunk(old, self.lines, l) == 0:
                                     self.lines[l : l + len(old)] = new
                                     self.offset += len(new) - len(old)
                                     self.skew = l - orig_start
                                     self.dirty = True
                                     offset = l - orig_start - fuzzlen
                                     if fuzzlen:
                                         msg = _("Hunk #%d succeeded at %d "
                                                 "with fuzz %d "
                                                 "(offset %d lines).\n")
                                         self.printfile(True)
                                         self.ui.warn(msg %
                                             (h.number, l + 1, fuzzlen, offset))
                                     else:
                                         msg = _("Hunk #%d succeeded at %d "
                                                 "(offset %d lines).\n")
                                         self.ui.note(msg % (h.number, l + 1, offset))
                                     return fuzzlen
                     self.printfile(True)
                     self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
                     self.rej.append(horig)
                     return -1
                 def close(self):
                     if self.dirty:
                         self.writelines(self.fname, self.lines, self.mode)
                     self.write_rej()
                     return len(self.rej)
             class header(object):
                 """patch header
                 """
                 diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')
                 diff_re = re.compile('diff -r .* (.*)$')
                 allhunks_re = re.compile('(?:index|deleted file) ')
                 pretty_re = re.compile('(?:new file|deleted file) ')
                 special_re = re.compile('(?:index|deleted|copy|rename) ')
                 newfile_re = re.compile('(?:new file)')
                 def __init__(self, header):
                     self.header = header
                     self.hunks = []
                 def binary(self):
                     return any(h.startswith('index ') for h in self.header)
                 def pretty(self, fp):
                     for h in self.header:
                         if h.startswith('index '):
                             fp.write(_('this modifies a binary file (all or nothing)\n'))
                             break
                         if self.pretty_re.match(h):
                             fp.write(h)
                             if self.binary():
                                 fp.write(_('this is a binary file\n'))
                             break
                         if h.startswith('---'):
                             fp.write(_('%d hunks, %d lines changed\n') %
                                      (len(self.hunks),
                                       sum([max(h.added, h.removed) for h in self.hunks])))
                             break
                         fp.write(h)
                 def write(self, fp):
                     fp.write(''.join(self.header))
                 def allhunks(self):
                     return any(self.allhunks_re.match(h) for h in self.header)
                 def files(self):
                     match = self.diffgit_re.match(self.header[0])
                     if match:
                         fromfile, tofile = match.groups()
                         if fromfile == tofile:
                             return [fromfile]
                         return [fromfile, tofile]
                     else:
                         return self.diff_re.match(self.header[0]).groups()
                 def filename(self):
                     return self.files()[-1]
                 def __repr__(self):
                     return '<header %s>' % (' '.join(map(repr, self.files())))
                 def isnewfile(self):
                     return any(self.newfile_re.match(h) for h in self.header)
                 def special(self):
                     # Special files are shown only at the header level and not at the hunk
                     # level for example a file that has been deleted is a special file.
                     # The user cannot change the content of the operation, in the case of
                     # the deleted file he has to take the deletion or not take it, he
                     # cannot take some of it.
                     # Newly added files are special if they are empty, they are not special
                     # if they have some content as we want to be able to change it
                     nocontent = len(self.header) == 2
                     emptynewfile = self.isnewfile() and nocontent
                     return emptynewfile or \
                             any(self.special_re.match(h) for h in self.header)
             class recordhunk(object):
                 """patch hunk
                 XXX shouldn't we merge this with the other hunk class?
                 """
                 def __init__(self, header, fromline, toline, proc, before, hunk, after,
                              maxcontext=None):
                     def trimcontext(lines, reverse=False):
                         if maxcontext is not None:
                             delta = len(lines) - maxcontext
                             if delta > 0:
                                 if reverse:
                                     return delta, lines[delta:]
                                 else:
                                     return delta, lines[:maxcontext]
                         return 0, lines
                     self.header = header
                     trimedbefore, self.before = trimcontext(before, True)
                     self.fromline = fromline + trimedbefore
                     self.toline = toline + trimedbefore
                     _trimedafter, self.after = trimcontext(after, False)
                     self.proc = proc
                     self.hunk = hunk
                     self.added, self.removed = self.countchanges(self.hunk)
                 def __eq__(self, v):
                     if not isinstance(v, recordhunk):
                         return False
                     return ((v.hunk == self.hunk) and
                             (v.proc == self.proc) and
                             (self.fromline == v.fromline) and
                             (self.header.files() == v.header.files()))
                 def __hash__(self):
                     return hash((tuple(self.hunk),
                         tuple(self.header.files()),
                         self.fromline,
                         self.proc))
                 def countchanges(self, hunk):
                     """hunk -> (n+,n-)"""
                     add = len([h for h in hunk if h.startswith('+')])
                     rem = len([h for h in hunk if h.startswith('-')])
                     return add, rem
                 def reversehunk(self):
                     """return another recordhunk which is the reverse of the hunk
                     If this hunk is diff(A, B), the returned hunk is diff(B, A). To do
                     that, swap fromline/toline and +/- signs while keep other things
                     unchanged.
                     """
                     m = {'+': '-', '-': '+', '\\': '\\'}
                     hunk = ['%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk]
                     return recordhunk(self.header, self.toline, self.fromline, self.proc,
                                       self.before, hunk, self.after)
                 def write(self, fp):
                     delta = len(self.before) + len(self.after)
                     if self.after and self.after[-1] == '\\ No newline at end of file\n':
                         delta -= 1
                     fromlen = delta + self.removed
                     tolen = delta + self.added
                     fp.write('@@ -%d,%d +%d,%d @@%s\n' %
                              (self.fromline, fromlen, self.toline, tolen,
                               self.proc and (' ' + self.proc)))
                     fp.write(''.join(self.before + self.hunk + self.after))
                 pretty = write
                 def filename(self):
                     return self.header.filename()
                 def __repr__(self):
                     return '<hunk %r@%d>' % (self.filename(), self.fromline)
             def getmessages():
                 return {
                     'multiple': {
                         'apply': _("apply change %d/%d to '%s'?"),
                         'discard': _("discard change %d/%d to '%s'?"),
                         'record': _("record change %d/%d to '%s'?"),
                     },
                     'single': {
                         'apply': _("apply this change to '%s'?"),
                         'discard': _("discard this change to '%s'?"),
                         'record': _("record this change to '%s'?"),
                     },
                     'help': {
                         'apply': _('[Ynesfdaq?]'
                                      '$$ &Yes, apply this change'
                                      '$$ &No, skip this change'
                                      '$$ &Edit this change manually'
                                      '$$ &Skip remaining changes to this file'
                                      '$$ Apply remaining changes to this &file'
                                      '$$ &Done, skip remaining changes and files'
                                      '$$ Apply &all changes to all remaining files'
                                      '$$ &Quit, applying no changes'
                                      '$$ &? (display help)'),
                         'discard': _('[Ynesfdaq?]'
                                      '$$ &Yes, discard this change'
                                      '$$ &No, skip this change'
                                      '$$ &Edit this change manually'
                                      '$$ &Skip remaining changes to this file'
                                      '$$ Discard remaining changes to this &file'
                                      '$$ &Done, skip remaining changes and files'
                                      '$$ Discard &all changes to all remaining files'
                                      '$$ &Quit, discarding no changes'
                                      '$$ &? (display help)'),
                         'record': _('[Ynesfdaq?]'
                                     '$$ &Yes, record this change'
                                     '$$ &No, skip this change'
                                     '$$ &Edit this change manually'
                                     '$$ &Skip remaining changes to this file'
                                     '$$ Record remaining changes to this &file'
                                     '$$ &Done, skip remaining changes and files'
                                     '$$ Record &all changes to all remaining files'
                                     '$$ &Quit, recording no changes'
                                     '$$ &? (display help)'),
                     }
                 }
             def filterpatch(ui, headers, operation=None):
                 """Interactively filter patch chunks into applied-only chunks"""
                 messages = getmessages()
                 if operation is None:
                     operation = 'record'
                 def prompt(skipfile, skipall, query, chunk):
                     """prompt query, and process base inputs
                     - y/n for the rest of file
                     - y/n for the rest
                     - ? (help)
                     - q (quit)
                     Return True/False and possibly updated skipfile and skipall.
                     """
                     newpatches = None
                     if skipall is not None:
                         return skipall, skipfile, skipall, newpatches
                     if skipfile is not None:
                         return skipfile, skipfile, skipall, newpatches
                     while True:
                         resps = messages['help'][operation]
                         r = ui.promptchoice("%s %s" % (query, resps))
                         ui.write("\n")
                         if r == 8: # ?
                             for c, t in ui.extractchoices(resps)[1]:
                                 ui.write('%s - %s\n' % (c, encoding.lower(t)))
                             continue
                         elif r == 0: # yes
                             ret = True
                         elif r == 1: # no
                             ret = False
                         elif r == 2: # Edit patch
                             if chunk is None:
                                 ui.write(_('cannot edit patch for whole file'))
                                 ui.write("\n")
                                 continue
                             if chunk.header.binary():
                                 ui.write(_('cannot edit patch for binary file'))
                                 ui.write("\n")
                                 continue
                             # Patch comment based on the Git one (based on comment at end of
                             # https://mercurial-scm.org/wiki/RecordExtension)
                             phelp = '---' + _("""
             To remove '-' lines, make them ' ' lines (context).
             To remove '+' lines, delete them.
             Lines starting with # will be removed from the patch.
             If the patch applies cleanly, the edited hunk will immediately be
             added to the record list. If it does not apply cleanly, a rejects
             file will be generated: you can use that when you try again. If
             all lines of the hunk are removed, then the edit is aborted and
             the hunk is left unchanged.
             """)
                             (patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-",
                                                                   suffix=".diff")
                             ncpatchfp = None
                             try:
                                 # Write the initial patch
                                 f = util.nativeeolwriter(os.fdopen(patchfd, r'wb'))
                                 chunk.header.write(f)
                                 chunk.write(f)
                                 f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))
                                 f.close()
                                 # Start the editor and wait for it to complete
                                 editor = ui.geteditor()
                                 ret = ui.system("%s \"%s\"" % (editor, patchfn),
                                                 environ={'HGUSER': ui.username()},
                                                 blockedtag='filterpatch')
                                 if ret != 0:
                                     ui.warn(_("editor exited with exit code %d\n") % ret)
                                     continue
                                 # Remove comment lines
                                 patchfp = open(patchfn, r'rb')
                                 ncpatchfp = stringio()
                                 for line in util.iterfile(patchfp):
                                     line = util.fromnativeeol(line)
                                     if not line.startswith('#'):
                                         ncpatchfp.write(line)
                                 patchfp.close()
                                 ncpatchfp.seek(0)
                                 newpatches = parsepatch(ncpatchfp)
                             finally:
                                 os.unlink(patchfn)
                                 del ncpatchfp
                             # Signal that the chunk shouldn't be applied as-is, but
                             # provide the new patch to be used instead.
                             ret = False
                         elif r == 3: # Skip
                             ret = skipfile = False
                         elif r == 4: # file (Record remaining)
                             ret = skipfile = True
                         elif r == 5: # done, skip remaining
                             ret = skipall = False
                         elif r == 6: # all
                             ret = skipall = True
                         elif r == 7: # quit
                             raise error.Abort(_('user quit'))
                         return ret, skipfile, skipall, newpatches
                 seen = set()
                 applied = {}        # 'filename' -> [] of chunks
                 skipfile, skipall = None, None
                 pos, total = 1, sum(len(h.hunks) for h in headers)
                 for h in headers:
                     pos += len(h.hunks)
                     skipfile = None
                     fixoffset = 0
                     hdr = ''.join(h.header)
                     if hdr in seen:
                         continue
                     seen.add(hdr)
                     if skipall is None:
                         h.pretty(ui)
                     msg = (_('examine changes to %s?') %
                            _(' and ').join("'%s'" % f for f in h.files()))
                     r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)
                     if not r:
                         continue
                     applied[h.filename()] = [h]
                     if h.allhunks():
                         applied[h.filename()] += h.hunks
                         continue
                     for i, chunk in enumerate(h.hunks):
                         if skipfile is None and skipall is None:
                             chunk.pretty(ui)
                         if total == 1:
                             msg = messages['single'][operation] % chunk.filename()
                         else:
                             idx = pos - len(h.hunks) + i
                             msg = messages['multiple'][operation] % (idx, total,
                                                                      chunk.filename())
                         r, skipfile, skipall, newpatches = prompt(skipfile,
                                 skipall, msg, chunk)
                         if r:
                             if fixoffset:
                                 chunk = copy.copy(chunk)
                                 chunk.toline += fixoffset
                             applied[chunk.filename()].append(chunk)
                         elif newpatches is not None:
                             for newpatch in newpatches:
                                 for newhunk in newpatch.hunks:
                                     if fixoffset:
                                         newhunk.toline += fixoffset
                                     applied[newhunk.filename()].append(newhunk)
                         else:
                             fixoffset += chunk.removed - chunk.added
                 return (sum([h for h in applied.itervalues()
                            if h[0].special() or len(h) > 1], []), {})
             class hunk(object):
                 def __init__(self, desc, num, lr, context):
                     self.number = num
                     self.desc = desc
                     self.hunk = [desc]
                     self.a = []
                     self.b = []
                     self.starta = self.lena = None
                     self.startb = self.lenb = None
                     if lr is not None:
                         if context:
                             self.read_context_hunk(lr)
                         else:
                             self.read_unified_hunk(lr)
                 def getnormalized(self):
                     """Return a copy with line endings normalized to LF."""
                     def normalize(lines):
                         nlines = []
                         for line in lines:
                             if line.endswith('\r\n'):
                                 line = line[:-2] + '\n'
                             nlines.append(line)
                         return nlines
                     # Dummy object, it is rebuilt manually
                     nh = hunk(self.desc, self.number, None, None)
                     nh.number = self.number
                     nh.desc = self.desc
                     nh.hunk = self.hunk
                     nh.a = normalize(self.a)
                     nh.b = normalize(self.b)
                     nh.starta = self.starta
                     nh.startb = self.startb
                     nh.lena = self.lena
                     nh.lenb = self.lenb
                     return nh
                 def read_unified_hunk(self, lr):
                     m = unidesc.match(self.desc)
                     if not m:
                         raise PatchError(_("bad hunk #%d") % self.number)
                     self.starta, self.lena, self.startb, self.lenb = m.groups()
                     if self.lena is None:
                         self.lena = 1
                     else:
                         self.lena = int(self.lena)
                     if self.lenb is None:
                         self.lenb = 1
                     else:
                         self.lenb = int(self.lenb)
                     self.starta = int(self.starta)
                     self.startb = int(self.startb)
                     diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a,
                                          self.b)
                     # if we hit eof before finishing out the hunk, the last line will
                     # be zero length.  Lets try to fix it up.
                     while len(self.hunk[-1]) == 0:
                         del self.hunk[-1]
                         del self.a[-1]
                         del self.b[-1]
                         self.lena -= 1
                         self.lenb -= 1
                     self._fixnewline(lr)
                 def read_context_hunk(self, lr):
                     self.desc = lr.readline()
                     m = contextdesc.match(self.desc)
                     if not m:
                         raise PatchError(_("bad hunk #%d") % self.number)
                     self.starta, aend = m.groups()
                     self.starta = int(self.starta)
                     if aend is None:
                         aend = self.starta
                     self.lena = int(aend) - self.starta
                     if self.starta:
                         self.lena += 1
                     for x in xrange(self.lena):
                         l = lr.readline()
                         if l.startswith('---'):
                             # lines addition, old block is empty
                             lr.push(l)
                             break
                         s = l[2:]
                         if l.startswith('- ') or l.startswith('! '):
                             u = '-' + s
                         elif l.startswith('  '):
                             u = ' ' + s
                         else:
                             raise PatchError(_("bad hunk #%d old text line %d") %
                                              (self.number, x))
                         self.a.append(u)
                         self.hunk.append(u)
                     l = lr.readline()
                     if l.startswith('\ '):
                         s = self.a[-1][:-1]
                         self.a[-1] = s
                         self.hunk[-1] = s
                         l = lr.readline()
                     m = contextdesc.match(l)
                     if not m:
                         raise PatchError(_("bad hunk #%d") % self.number)
                     self.startb, bend = m.groups()
                     self.startb = int(self.startb)
                     if bend is None:
                         bend = self.startb
                     self.lenb = int(bend) - self.startb
                     if self.startb:
                         self.lenb += 1
                     hunki = 1
                     for x in xrange(self.lenb):
                         l = lr.readline()
                         if l.startswith('\ '):
                             # XXX: the only way to hit this is with an invalid line range.
                             # The no-eol marker is not counted in the line range, but I
                             # guess there are diff(1) out there which behave differently.
                             s = self.b[-1][:-1]
                             self.b[-1] = s
                             self.hunk[hunki - 1] = s
                             continue
                         if not l:
                             # line deletions, new block is empty and we hit EOF
                             lr.push(l)
                             break
                         s = l[2:]
                         if l.startswith('+ ') or l.startswith('! '):
                             u = '+' + s
                         elif l.startswith('  '):
                             u = ' ' + s
                         elif len(self.b) == 0:
                             # line deletions, new block is empty
                             lr.push(l)
                             break
                         else:
                             raise PatchError(_("bad hunk #%d old text line %d") %
                                              (self.number, x))
                         self.b.append(s)
                         while True:
                             if hunki >= len(self.hunk):
                                 h = ""
                             else:
                                 h = self.hunk[hunki]
                             hunki += 1
                             if h == u:
                                 break
                             elif h.startswith('-'):
                                 continue
                             else:
                                 self.hunk.insert(hunki - 1, u)
                                 break
                     if not self.a:
                         # this happens when lines were only added to the hunk
                         for x in self.hunk:
                             if x.startswith('-') or x.startswith(' '):
                                 self.a.append(x)
                     if not self.b:
                         # this happens when lines were only deleted from the hunk
                         for x in self.hunk:
                             if x.startswith('+') or x.startswith(' '):
                                 self.b.append(x[1:])
                     # @@ -start,len +start,len @@
                     self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
                                                          self.startb, self.lenb)
                     self.hunk[0] = self.desc
                     self._fixnewline(lr)
                 def _fixnewline(self, lr):
                     l = lr.readline()
                     if l.startswith('\ '):
                         diffhelpers.fix_newline(self.hunk, self.a, self.b)
                     else:
                         lr.push(l)
                 def complete(self):
                     return len(self.a) == self.lena and len(self.b) == self.lenb
                 def _fuzzit(self, old, new, fuzz, toponly):
                     # this removes context lines from the top and bottom of list 'l'.  It
                     # checks the hunk to make sure only context lines are removed, and then
                     # returns a new shortened list of lines.
                     fuzz = min(fuzz, len(old))
                     if fuzz:
                         top = 0
                         bot = 0
                         hlen = len(self.hunk)
                         for x in xrange(hlen - 1):
                             # the hunk starts with the @@ line, so use x+1
-                            if self.hunk[x + 1][0] == ' ':
+                            if self.hunk[x + 1].startswith(' '):
                                 top += 1
                             else:
                                 break
                         if not toponly:
                             for x in xrange(hlen - 1):
-                                if self.hunk[hlen - bot - 1][0] == ' ':
+                                if self.hunk[hlen - bot - 1].startswith(' '):
                                     bot += 1
                                 else:
                                     break
                         bot = min(fuzz, bot)
                         top = min(fuzz, top)
                         return old[top:len(old) - bot], new[top:len(new) - bot], top
                     return old, new, 0
                 def fuzzit(self, fuzz, toponly):
                     old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)
                     oldstart = self.starta + top
                     newstart = self.startb + top
                     # zero length hunk ranges already have their start decremented
                     if self.lena and oldstart > 0:
                         oldstart -= 1
                     if self.lenb and newstart > 0:
                         newstart -= 1
                     return old, oldstart, new, newstart
             class binhunk(object):
                 'A binary patch file.'
                 def __init__(self, lr, fname):
                     self.text = None
                     self.delta = False
                     self.hunk = ['GIT binary patch\n']
                     self._fname = fname
                     self._read(lr)
                 def complete(self):
                     return self.text is not None
                 def new(self, lines):
                     if self.delta:
                         return [applybindelta(self.text, ''.join(lines))]
                     return [self.text]
                 def _read(self, lr):
                     def getline(lr, hunk):
                         l = lr.readline()
                         hunk.append(l)
                         return l.rstrip('\r\n')
                     size = 0
                     while True:
                         line = getline(lr, self.hunk)
                         if not line:
                             raise PatchError(_('could not extract "%s" binary data')
                                              % self._fname)
                         if line.startswith('literal '):
                             size = int(line[8:].rstrip())
                             break
                         if line.startswith('delta '):
                             size = int(line[6:].rstrip())
                             self.delta = True
                             break
                     dec = []
                     line = getline(lr, self.hunk)
                     while len(line) > 1:
                         l = line[0:1]
                         if l <= 'Z' and l >= 'A':
                             l = ord(l) - ord('A') + 1
                         else:
                             l = ord(l) - ord('a') + 27
                         try:
                             dec.append(util.b85decode(line[1:])[:l])
                         except ValueError as e:
                             raise PatchError(_('could not decode "%s" binary patch: %s')
                                              % (self._fname, stringutil.forcebytestr(e)))
                         line = getline(lr, self.hunk)
                     text = zlib.decompress(''.join(dec))
                     if len(text) != size:
                         raise PatchError(_('"%s" length is %d bytes, should be %d')
                                          % (self._fname, len(text), size))
                     self.text = text
             def parsefilename(str):
                 # --- filename \t|space stuff
                 s = str[4:].rstrip('\r\n')
                 i = s.find('\t')
                 if i < 0:
                     i = s.find(' ')
                     if i < 0:
                         return s
                 return s[:i]
             def reversehunks(hunks):
                 '''reverse the signs in the hunks given as argument
                 This function operates on hunks coming out of patch.filterpatch, that is
                 a list of the form: [header1, hunk1, hunk2, header2...]. Example usage:
                 >>> rawpatch = b"""diff --git a/folder1/g b/folder1/g
                 ... --- a/folder1/g
                 ... +++ b/folder1/g
                 ... @@ -1,7 +1,7 @@
                 ... +firstline
                 ...  c
                 ...  1
                 ...  2
                 ... + 3
                 ... -4
                 ...  5
                 ...  d
                 ... +lastline"""
                 >>> hunks = parsepatch([rawpatch])
                 >>> hunkscomingfromfilterpatch = []
                 >>> for h in hunks:
                 ...     hunkscomingfromfilterpatch.append(h)
                 ...     hunkscomingfromfilterpatch.extend(h.hunks)
                 >>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)
                 >>> from . import util
                 >>> fp = util.stringio()
                 >>> for c in reversedhunks:
                 ...      c.write(fp)
                 >>> fp.seek(0) or None
                 >>> reversedpatch = fp.read()
                 >>> print(pycompat.sysstr(reversedpatch))
                 diff --git a/folder1/g b/folder1/g
                 --- a/folder1/g
                 +++ b/folder1/g
                 @@ -1,4 +1,3 @@
                 -firstline
                  c
                 @@ -2,6 +1,6 @@
                  c
                 - 3
                 +4
                  d
                 @@ -6,3 +5,2 @@
                  d
                 -lastline
                 '''
                 newhunks = []
                 for c in hunks:
                     if util.safehasattr(c, 'reversehunk'):
                         c = c.reversehunk()
                     newhunks.append(c)
                 return newhunks
             def parsepatch(originalchunks, maxcontext=None):
                 """patch -> [] of headers -> [] of hunks
                 If maxcontext is not None, trim context lines if necessary.
                 >>> rawpatch = b'''diff --git a/folder1/g b/folder1/g
                 ... --- a/folder1/g
                 ... +++ b/folder1/g
                 ... @@ -1,8 +1,10 @@
                 ...  1
                 ...  2
                 ... -3
                 ...  4
                 ...  5
                 ...  6
                 ... +6.1
                 ... +6.2
                 ...  7
                 ...  8
                 ... +9'''
                 >>> out = util.stringio()
                 >>> headers = parsepatch([rawpatch], maxcontext=1)
                 >>> for header in headers:
                 ...     header.write(out)
                 ...     for hunk in header.hunks:
                 ...         hunk.write(out)
                 >>> print(pycompat.sysstr(out.getvalue()))
                 diff --git a/folder1/g b/folder1/g
                 --- a/folder1/g
                 +++ b/folder1/g
                 @@ -2,3 +2,2 @@
                 -3
                 @@ -6,2 +5,4 @@
                 +6.1
                 +6.2
                 @@ -8,1 +9,2 @@
                 +9
                 """
                 class parser(object):
                     """patch parsing state machine"""
                     def __init__(self):
                         self.fromline = 0
                         self.toline = 0
                         self.proc = ''
                         self.header = None
                         self.context = []
                         self.before = []
                         self.hunk = []
                         self.headers = []
                     def addrange(self, limits):
                         fromstart, fromend, tostart, toend, proc = limits
                         self.fromline = int(fromstart)
                         self.toline = int(tostart)
                         self.proc = proc
                     def addcontext(self, context):
                         if self.hunk:
                             h = recordhunk(self.header, self.fromline, self.toline,
                                     self.proc, self.before, self.hunk, context, maxcontext)
                             self.header.hunks.append(h)
                             self.fromline += len(self.before) + h.removed
                             self.toline += len(self.before) + h.added
                             self.before = []
                             self.hunk = []
                         self.context = context
                     def addhunk(self, hunk):
                         if self.context:
                             self.before = self.context
                             self.context = []
                         self.hunk = hunk
                     def newfile(self, hdr):
                         self.addcontext([])
                         h = header(hdr)
                         self.headers.append(h)
                         self.header = h
                     def addother(self, line):
                         pass # 'other' lines are ignored
                     def finished(self):
                         self.addcontext([])
                         return self.headers
                     transitions = {
                         'file': {'context': addcontext,
                                  'file': newfile,
                                  'hunk': addhunk,
                                  'range': addrange},
                         'context': {'file': newfile,
                                     'hunk': addhunk,
                                     'range': addrange,
                                     'other': addother},
                         'hunk': {'context': addcontext,
                                  'file': newfile,
                                  'range': addrange},
                         'range': {'context': addcontext,
                                   'hunk': addhunk},
                         'other': {'other': addother},
                         }
                 p = parser()
                 fp = stringio()
                 fp.write(''.join(originalchunks))
                 fp.seek(0)
                 state = 'context'
                 for newstate, data in scanpatch(fp):
                     try:
                         p.transitions[state][newstate](p, data)
                     except KeyError:
                         raise PatchError('unhandled transition: %s -> %s' %
                                                (state, newstate))
                     state = newstate
                 del fp
                 return p.finished()
             def pathtransform(path, strip, prefix):
                 '''turn a path from a patch into a path suitable for the repository
                 prefix, if not empty, is expected to be normalized with a / at the end.
                 Returns (stripped components, path in repository).
                 >>> pathtransform(b'a/b/c', 0, b'')
                 ('', 'a/b/c')
                 >>> pathtransform(b'   a/b/c   ', 0, b'')
                 ('', '   a/b/c')
                 >>> pathtransform(b'   a/b/c   ', 2, b'')
                 ('a/b/', 'c')
                 >>> pathtransform(b'a/b/c', 0, b'd/e/')
                 ('', 'd/e/a/b/c')
                 >>> pathtransform(b'   a//b/c   ', 2, b'd/e/')
                 ('a//b/', 'd/e/c')
                 >>> pathtransform(b'a/b/c', 3, b'')
                 Traceback (most recent call last):
                 PatchError: unable to strip away 1 of 3 dirs from a/b/c
                 '''
                 pathlen = len(path)
                 i = 0
                 if strip == 0:
                     return '', prefix + path.rstrip()
                 count = strip
                 while count > 0:
                     i = path.find('/', i)
                     if i == -1:
                         raise PatchError(_("unable to strip away %d of %d dirs from %s") %
                                          (count, strip, path))
                     i += 1
                     # consume '//' in the path
                     while i < pathlen - 1 and path[i:i + 1] == '/':
                         i += 1
                     count -= 1
                 return path[:i].lstrip(), prefix + path[i:].rstrip()
             def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):
                 nulla = afile_orig == "/dev/null"
                 nullb = bfile_orig == "/dev/null"
                 create = nulla and hunk.starta == 0 and hunk.lena == 0
                 remove = nullb and hunk.startb == 0 and hunk.lenb == 0
                 abase, afile = pathtransform(afile_orig, strip, prefix)
                 gooda = not nulla and backend.exists(afile)
                 bbase, bfile = pathtransform(bfile_orig, strip, prefix)
                 if afile == bfile:
                     goodb = gooda
                 else:
                     goodb = not nullb and backend.exists(bfile)
                 missing = not goodb and not gooda and not create
                 # some diff programs apparently produce patches where the afile is
                 # not /dev/null, but afile starts with bfile
                 abasedir = afile[:afile.rfind('/') + 1]
                 bbasedir = bfile[:bfile.rfind('/') + 1]
                 if (missing and abasedir == bbasedir and afile.startswith(bfile)
                     and hunk.starta == 0 and hunk.lena == 0):
                     create = True
                     missing = False
                 # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
                 # diff is between a file and its backup. In this case, the original
                 # file should be patched (see original mpatch code).
                 isbackup = (abase == bbase and bfile.startswith(afile))
                 fname = None
                 if not missing:
                     if gooda and goodb:
                         if isbackup:
                             fname = afile
                         else:
                             fname = bfile
                     elif gooda:
                         fname = afile
                 if not fname:
                     if not nullb:
                         if isbackup:
                             fname = afile
                         else:
                             fname = bfile
                     elif not nulla:
                         fname = afile
                     else:
                         raise PatchError(_("undefined source and destination files"))
                 gp = patchmeta(fname)
                 if create:
                     gp.op = 'ADD'
                 elif remove:
                     gp.op = 'DELETE'
                 return gp
             def scanpatch(fp):
                 """like patch.iterhunks, but yield different events
                 - ('file',    [header_lines + fromfile + tofile])
                 - ('context', [context_lines])
                 - ('hunk',    [hunk_lines])
                 - ('range',   (-start,len, +start,len, proc))
                 """
                 lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
                 lr = linereader(fp)
                 def scanwhile(first, p):
                     """scan lr while predicate holds"""
                     lines = [first]
                     for line in iter(lr.readline, ''):
                         if p(line):
                             lines.append(line)
                         else:
                             lr.push(line)
                             break
                     return lines
                 for line in iter(lr.readline, ''):
                     if line.startswith('diff --git a/') or line.startswith('diff -r '):
                         def notheader(line):
                             s = line.split(None, 1)
                             return not s or s[0] not in ('---', 'diff')
                         header = scanwhile(line, notheader)
                         fromfile = lr.readline()
                         if fromfile.startswith('---'):
                             tofile = lr.readline()
                             header += [fromfile, tofile]
                         else:
                             lr.push(fromfile)
                         yield 'file', header
-                    elif line[0:1] == ' ':
+                    elif line.startswith(' '):
-                        yield 'context', scanwhile(line, lambda l: l[0] in ' \\')
+                        cs = (' ', '\\')
-                    elif line[0] in '-+':
+                        yield 'context', scanwhile(line, lambda l: l.startswith(cs))
-                        yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\')
+                    elif line.startswith(('-', '+')):
+                        cs = ('-', '+', '\\')
+                        yield 'hunk', scanwhile(line, lambda l: l.startswith(cs))
                     else:
                         m = lines_re.match(line)
                         if m:
                             yield 'range', m.groups()
                         else:
                             yield 'other', line
             def scangitpatch(lr, firstline):
                 """
                 Git patches can emit:
                 - rename a to b
                 - change b
                 - copy a to c
                 - change c
                 We cannot apply this sequence as-is, the renamed 'a' could not be
                 found for it would have been renamed already. And we cannot copy
                 from 'b' instead because 'b' would have been changed already. So
                 we scan the git patch for copy and rename commands so we can
                 perform the copies ahead of time.
                 """
                 pos = 0
                 try:
                     pos = lr.fp.tell()
                     fp = lr.fp
                 except IOError:
                     fp = stringio(lr.fp.read())
                 gitlr = linereader(fp)
                 gitlr.push(firstline)
                 gitpatches = readgitpatch(gitlr)
                 fp.seek(pos)
                 return gitpatches
             def iterhunks(fp):
                 """Read a patch and yield the following events:
                 - ("file", afile, bfile, firsthunk): select a new target file.
                 - ("hunk", hunk): a new hunk is ready to be applied, follows a
                 "file" event.
                 - ("git", gitchanges): current diff is in git format, gitchanges
                 maps filenames to gitpatch records. Unique event.
                 """
                 afile = ""
                 bfile = ""
                 state = None
                 hunknum = 0
                 emitfile = newfile = False
                 gitpatches = None
                 # our states
                 BFILE = 1
                 context = None
                 lr = linereader(fp)
                 for x in iter(lr.readline, ''):
                     if state == BFILE and (
                         (not context and x.startswith('@'))
                         or (context is not False and x.startswith('***************'))
                         or x.startswith('GIT binary patch')):
                         gp = None
                         if (gitpatches and
                             gitpatches[-1].ispatching(afile, bfile)):
                             gp = gitpatches.pop()
                         if x.startswith('GIT binary patch'):
                             h = binhunk(lr, gp.path)
                         else:
                             if context is None and x.startswith('***************'):
                                 context = True
                             h = hunk(x, hunknum + 1, lr, context)
                         hunknum += 1
                         if emitfile:
                             emitfile = False
                             yield 'file', (afile, bfile, h, gp and gp.copy() or None)
                         yield 'hunk', h
                     elif x.startswith('diff --git a/'):
                         m = gitre.match(x.rstrip(' \r\n'))
                         if not m:
                             continue
                         if gitpatches is None:
                             # scan whole input for git metadata
                             gitpatches = scangitpatch(lr, x)
                             yield 'git', [g.copy() for g in gitpatches
                                           if g.op in ('COPY', 'RENAME')]
                             gitpatches.reverse()
                         afile = 'a/' + m.group(1)
                         bfile = 'b/' + m.group(2)
                         while gitpatches and not gitpatches[-1].ispatching(afile, bfile):
                             gp = gitpatches.pop()
                             yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
                         if not gitpatches:
                             raise PatchError(_('failed to synchronize metadata for "%s"')
                                              % afile[2:])
                         gp = gitpatches[-1]
                         newfile = True
                     elif x.startswith('---'):
                         # check for a unified diff
                         l2 = lr.readline()
                         if not l2.startswith('+++'):
                             lr.push(l2)
                             continue
                         newfile = True
                         context = False
                         afile = parsefilename(x)
                         bfile = parsefilename(l2)
                     elif x.startswith('***'):
                         # check for a context diff
                         l2 = lr.readline()
                         if not l2.startswith('---'):
                             lr.push(l2)
                             continue
                         l3 = lr.readline()
                         lr.push(l3)
                         if not l3.startswith("***************"):
                             lr.push(l2)
                             continue
                         newfile = True
                         context = True
                         afile = parsefilename(x)
                         bfile = parsefilename(l2)
                     if newfile:
                         newfile = False
                         emitfile = True
                         state = BFILE
                         hunknum = 0
                 while gitpatches:
                     gp = gitpatches.pop()
                     yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
             def applybindelta(binchunk, data):
                 """Apply a binary delta hunk
                 The algorithm used is the algorithm from git's patch-delta.c
                 """
                 def deltahead(binchunk):
                     i = 0
                     for c in binchunk:
                         i += 1
                         if not (ord(c) & 0x80):
                             return i
                     return i
                 out = ""
                 s = deltahead(binchunk)
                 binchunk = binchunk[s:]
                 s = deltahead(binchunk)
                 binchunk = binchunk[s:]
                 i = 0
                 while i < len(binchunk):
                     cmd = ord(binchunk[i])
                     i += 1
                     if (cmd & 0x80):
                         offset = 0
                         size = 0
                         if (cmd & 0x01):
                             offset = ord(binchunk[i])
                             i += 1
                         if (cmd & 0x02):
                             offset |= ord(binchunk[i]) << 8
                             i += 1
                         if (cmd & 0x04):
                             offset |= ord(binchunk[i]) << 16
                             i += 1
                         if (cmd & 0x08):
                             offset |= ord(binchunk[i]) << 24
                             i += 1
                         if (cmd & 0x10):
                             size = ord(binchunk[i])
                             i += 1
                         if (cmd & 0x20):
                             size |= ord(binchunk[i]) << 8
                             i += 1
                         if (cmd & 0x40):
                             size |= ord(binchunk[i]) << 16
                             i += 1
                         if size == 0:
                             size = 0x10000
                         offset_end = offset + size
                         out += data[offset:offset_end]
                     elif cmd != 0:
                         offset_end = i + cmd
                         out += binchunk[i:offset_end]
                         i += cmd
                     else:
                         raise PatchError(_('unexpected delta opcode 0'))
                 return out
             def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'):
                 """Reads a patch from fp and tries to apply it.
                 Returns 0 for a clean patch, -1 if any rejects were found and 1 if
                 there was any fuzz.
                 If 'eolmode' is 'strict', the patch content and patched file are
                 read in binary mode. Otherwise, line endings are ignored when
                 patching then normalized according to 'eolmode'.
                 """
                 return _applydiff(ui, fp, patchfile, backend, store, strip=strip,
                                   prefix=prefix, eolmode=eolmode)
             def _canonprefix(repo, prefix):
                 if prefix:
                     prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix)
                     if prefix != '':
                         prefix += '/'
                 return prefix
             def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='',
                            eolmode='strict'):
                 prefix = _canonprefix(backend.repo, prefix)
                 def pstrip(p):
                     return pathtransform(p, strip - 1, prefix)[1]
                 rejects = 0
                 err = 0
                 current_file = None
                 for state, values in iterhunks(fp):
                     if state == 'hunk':
                         if not current_file:
                             continue
                         ret = current_file.apply(values)
                         if ret > 0:
                             err = 1
                     elif state == 'file':
                         if current_file:
                             rejects += current_file.close()
                             current_file = None
                         afile, bfile, first_hunk, gp = values
                         if gp:
                             gp.path = pstrip(gp.path)
                             if gp.oldpath:
                                 gp.oldpath = pstrip(gp.oldpath)
                         else:
                             gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
                                                prefix)
                         if gp.op == 'RENAME':
                             backend.unlink(gp.oldpath)
                         if not first_hunk:
                             if gp.op == 'DELETE':
                                 backend.unlink(gp.path)
                                 continue
                             data, mode = None, None
                             if gp.op in ('RENAME', 'COPY'):
                                 data, mode = store.getfile(gp.oldpath)[:2]
                                 if data is None:
                                     # This means that the old path does not exist
                                     raise PatchError(_("source file '%s' does not exist")
                                                        % gp.oldpath)
                             if gp.mode:
                                 mode = gp.mode
                                 if gp.op == 'ADD':
                                     # Added files without content have no hunk and
                                     # must be created
                                     data = ''
                             if data or mode:
                                 if (gp.op in ('ADD', 'RENAME', 'COPY')
                                     and backend.exists(gp.path)):
                                     raise PatchError(_("cannot create %s: destination "
                                                        "already exists") % gp.path)
                                 backend.setfile(gp.path, data, mode, gp.oldpath)
                             continue
                         try:
                             current_file = patcher(ui, gp, backend, store,
                                                    eolmode=eolmode)
                         except PatchError as inst:
                             ui.warn(str(inst) + '\n')
                             current_file = None
                             rejects += 1
                             continue
                     elif state == 'git':
                         for gp in values:
                             path = pstrip(gp.oldpath)
                             data, mode = backend.getfile(path)
                             if data is None:
                                 # The error ignored here will trigger a getfile()
                                 # error in a place more appropriate for error
                                 # handling, and will not interrupt the patching
                                 # process.
                                 pass
                             else:
                                 store.setfile(path, data, mode)
                     else:
                         raise error.Abort(_('unsupported parser state: %s') % state)
                 if current_file:
                     rejects += current_file.close()
                 if rejects:
                     return -1
                 return err
             def _externalpatch(ui, repo, patcher, patchname, strip, files,
                                similarity):
                 """use <patcher> to apply <patchname> to the working directory.
                 returns whether patch was applied with fuzz factor."""
                 fuzz = False
                 args = []
                 cwd = repo.root
                 if cwd:
                     args.append('-d %s' % procutil.shellquote(cwd))
                 cmd = ('%s %s -p%d < %s'
                        % (patcher, ' '.join(args), strip, procutil.shellquote(patchname)))
                 fp = procutil.popen(cmd, 'rb')
                 try:
                     for line in util.iterfile(fp):
                         line = line.rstrip()
                         ui.note(line + '\n')
                         if line.startswith('patching file '):
                             pf = util.parsepatchoutput(line)
                             printed_file = False
                             files.add(pf)
                         elif line.find('with fuzz') >= 0:
                             fuzz = True
                             if not printed_file:
                                 ui.warn(pf + '\n')
                                 printed_file = True
                             ui.warn(line + '\n')
                         elif line.find('saving rejects to file') >= 0:
                             ui.warn(line + '\n')
                         elif line.find('FAILED') >= 0:
                             if not printed_file:
                                 ui.warn(pf + '\n')
                                 printed_file = True
                             ui.warn(line + '\n')
                 finally:
                     if files:
                         scmutil.marktouched(repo, files, similarity)
                 code = fp.close()
                 if code:
                     raise PatchError(_("patch command failed: %s") %
                                      procutil.explainexit(code))
                 return fuzz
             def patchbackend(ui, backend, patchobj, strip, prefix, files=None,
                              eolmode='strict'):
                 if files is None:
                     files = set()
                 if eolmode is None:
                     eolmode = ui.config('patch', 'eol')
                 if eolmode.lower() not in eolmodes:
                     raise error.Abort(_('unsupported line endings type: %s') % eolmode)
                 eolmode = eolmode.lower()
                 store = filestore()
                 try:
                     fp = open(patchobj, 'rb')
                 except TypeError:
                     fp = patchobj
                 try:
                     ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix,
                                     eolmode=eolmode)
                 finally:
                     if fp != patchobj:
                         fp.close()
                     files.update(backend.close())
                     store.close()
                 if ret < 0:
                     raise PatchError(_('patch failed to apply'))
                 return ret > 0
             def internalpatch(ui, repo, patchobj, strip, prefix='', files=None,
                               eolmode='strict', similarity=0):
                 """use builtin patch to apply <patchobj> to the working directory.
                 returns whether patch was applied with fuzz factor."""
                 backend = workingbackend(ui, repo, similarity)
                 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
             def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None,
                           eolmode='strict'):
                 backend = repobackend(ui, repo, ctx, store)
                 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
             def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict',
                       similarity=0):
                 """Apply <patchname> to the working directory.
                 'eolmode' specifies how end of lines should be handled. It can be:
                 - 'strict': inputs are read in binary mode, EOLs are preserved
                 - 'crlf': EOLs are ignored when patching and reset to CRLF
                 - 'lf': EOLs are ignored when patching and reset to LF
                 - None: get it from user settings, default to 'strict'
                 'eolmode' is ignored when using an external patcher program.
                 Returns whether patch was applied with fuzz factor.
                 """
                 patcher = ui.config('ui', 'patch')
                 if files is None:
                     files = set()
                 if patcher:
                     return _externalpatch(ui, repo, patcher, patchname, strip,
                                           files, similarity)
                 return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode,
                                      similarity)
             def changedfiles(ui, repo, patchpath, strip=1, prefix=''):
                 backend = fsbackend(ui, repo.root)
                 prefix = _canonprefix(repo, prefix)
                 with open(patchpath, 'rb') as fp:
                     changed = set()
                     for state, values in iterhunks(fp):
                         if state == 'file':
                             afile, bfile, first_hunk, gp = values
                             if gp:
                                 gp.path = pathtransform(gp.path, strip - 1, prefix)[1]
                                 if gp.oldpath:
                                     gp.oldpath = pathtransform(gp.oldpath, strip - 1,
                                                                prefix)[1]
                             else:
                                 gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
                                                    prefix)
                             changed.add(gp.path)
                             if gp.op == 'RENAME':
                                 changed.add(gp.oldpath)
                         elif state not in ('hunk', 'git'):
                             raise error.Abort(_('unsupported parser state: %s') % state)
                     return changed
             class GitDiffRequired(Exception):
                 pass
             def diffallopts(ui, opts=None, untrusted=False, section='diff'):
                 '''return diffopts with all features supported and parsed'''
                 return difffeatureopts(ui, opts=opts, untrusted=untrusted, section=section,
                                        git=True, whitespace=True, formatchanging=True)
             diffopts = diffallopts
             def difffeatureopts(ui, opts=None, untrusted=False, section='diff', git=False,
                                 whitespace=False, formatchanging=False):
                 '''return diffopts with only opted-in features parsed
                 Features:
                 - git: git-style diffs
                 - whitespace: whitespace options like ignoreblanklines and ignorews
                 - formatchanging: options that will likely break or cause correctness issues
                   with most diff parsers
                 '''
                 def get(key, name=None, getter=ui.configbool, forceplain=None):
                     if opts:
                         v = opts.get(key)
                         # diffopts flags are either None-default (which is passed
                         # through unchanged, so we can identify unset values), or
                         # some other falsey default (eg --unified, which defaults
                         # to an empty string). We only want to override the config
                         # entries from hgrc with command line values if they
                         # appear to have been set, which is any truthy value,
                         # True, or False.
                         if v or isinstance(v, bool):
                             return v
                     if forceplain is not None and ui.plain():
                         return forceplain
                     return getter(section, name or key, untrusted=untrusted)
                 # core options, expected to be understood by every diff parser
                 buildopts = {
                     'nodates': get('nodates'),
                     'showfunc': get('show_function', 'showfunc'),
                     'context': get('unified', getter=ui.config),
                 }
                 buildopts['worddiff'] = ui.configbool('experimental', 'worddiff')
                 buildopts['xdiff'] = ui.configbool('experimental', 'xdiff')
                 if git:
                     buildopts['git'] = get('git')
                     # since this is in the experimental section, we need to call
                     # ui.configbool directory
                     buildopts['showsimilarity'] = ui.configbool('experimental',
                                                                 'extendedheader.similarity')
                     # need to inspect the ui object instead of using get() since we want to
                     # test for an int
                     hconf = ui.config('experimental', 'extendedheader.index')
                     if hconf is not None:
                         hlen = None
                         try:
                             # the hash config could be an integer (for length of hash) or a
                             # word (e.g. short, full, none)
                             hlen = int(hconf)
                             if hlen < 0 or hlen > 40:
                                 msg = _("invalid length for extendedheader.index: '%d'\n")
                                 ui.warn(msg % hlen)
                         except ValueError:
                             # default value
                             if hconf == 'short' or hconf == '':
                                 hlen = 12
                             elif hconf == 'full':
                                 hlen = 40
                             elif hconf != 'none':
                                 msg = _("invalid value for extendedheader.index: '%s'\n")
                                 ui.warn(msg % hconf)
                         finally:
                             buildopts['index'] = hlen
                 if whitespace:
                     buildopts['ignorews'] = get('ignore_all_space', 'ignorews')
                     buildopts['ignorewsamount'] = get('ignore_space_change',
                                                       'ignorewsamount')
                     buildopts['ignoreblanklines'] = get('ignore_blank_lines',
                                                         'ignoreblanklines')
                     buildopts['ignorewseol'] = get('ignore_space_at_eol', 'ignorewseol')
                 if formatchanging:
                     buildopts['text'] = opts and opts.get('text')
                     binary = None if opts is None else opts.get('binary')
                     buildopts['nobinary'] = (not binary if binary is not None
                                              else get('nobinary', forceplain=False))
                     buildopts['noprefix'] = get('noprefix', forceplain=False)
                 return mdiff.diffopts(**pycompat.strkwargs(buildopts))
             def diff(repo, node1=None, node2=None, match=None, changes=None,
                      opts=None, losedatafn=None, prefix='', relroot='', copy=None,
                      hunksfilterfn=None):
                 '''yields diff of changes to files between two nodes, or node and
                 working directory.
                 if node1 is None, use first dirstate parent instead.
                 if node2 is None, compare node1 with working directory.
                 losedatafn(**kwarg) is a callable run when opts.upgrade=True and
                 every time some change cannot be represented with the current
                 patch format. Return False to upgrade to git patch format, True to
                 accept the loss or raise an exception to abort the diff. It is
                 called with the name of current file being diffed as 'fn'. If set
                 to None, patches will always be upgraded to git format when
                 necessary.
                 prefix is a filename prefix that is prepended to all filenames on
                 display (used for subrepos).
                 relroot, if not empty, must be normalized with a trailing /. Any match
                 patterns that fall outside it will be ignored.
                 copy, if not empty, should contain mappings {dst@y: src@x} of copy
                 information.
                 hunksfilterfn, if not None, should be a function taking a filectx and
                 hunks generator that may yield filtered hunks.
                 '''
                 for fctx1, fctx2, hdr, hunks in diffhunks(
                         repo, node1=node1, node2=node2,
                         match=match, changes=changes, opts=opts,
                         losedatafn=losedatafn, prefix=prefix, relroot=relroot, copy=copy,
                 ):
                     if hunksfilterfn is not None:
                         # If the file has been removed, fctx2 is None; but this should
                         # not occur here since we catch removed files early in
                         # logcmdutil.getlinerangerevs() for 'hg log -L'.
                         assert fctx2 is not None, \
                             'fctx2 unexpectly None in diff hunks filtering'
                         hunks = hunksfilterfn(fctx2, hunks)
                     text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
                     if hdr and (text or len(hdr) > 1):
                         yield '\n'.join(hdr) + '\n'
                     if text:
                         yield text
             def diffhunks(repo, node1=None, node2=None, match=None, changes=None,
                           opts=None, losedatafn=None, prefix='', relroot='', copy=None):
                 """Yield diff of changes to files in the form of (`header`, `hunks`) tuples
                 where `header` is a list of diff headers and `hunks` is an iterable of
                 (`hunkrange`, `hunklines`) tuples.
                 See diff() for the meaning of parameters.
                 """
                 if opts is None:
                     opts = mdiff.defaultopts
                 if not node1 and not node2:
                     node1 = repo.dirstate.p1()
                 def lrugetfilectx():
                     cache = {}
                     order = collections.deque()
                     def getfilectx(f, ctx):
                         fctx = ctx.filectx(f, filelog=cache.get(f))
                         if f not in cache:
                             if len(cache) > 20:
                                 del cache[order.popleft()]
                             cache[f] = fctx.filelog()
                         else:
                             order.remove(f)
                         order.append(f)
                         return fctx
                     return getfilectx
                 getfilectx = lrugetfilectx()
                 ctx1 = repo[node1]
                 ctx2 = repo[node2]
                 relfiltered = False
                 if relroot != '' and match.always():
                     # as a special case, create a new matcher with just the relroot
                     pats = [relroot]
                     match = scmutil.match(ctx2, pats, default='path')
                     relfiltered = True
                 if not changes:
                     changes = repo.status(ctx1, ctx2, match=match)
                 modified, added, removed = changes[:3]
                 if not modified and not added and not removed:
                     return []
                 if repo.ui.debugflag:
                     hexfunc = hex
                 else:
                     hexfunc = short
                 revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
                 if copy is None:
                     copy = {}
                     if opts.git or opts.upgrade:
                         copy = copies.pathcopies(ctx1, ctx2, match=match)
                 if relroot is not None:
                     if not relfiltered:
                         # XXX this would ideally be done in the matcher, but that is
                         # generally meant to 'or' patterns, not 'and' them. In this case we
                         # need to 'and' all the patterns from the matcher with relroot.
                         def filterrel(l):
                             return [f for f in l if f.startswith(relroot)]
                         modified = filterrel(modified)
                         added = filterrel(added)
                         removed = filterrel(removed)
                         relfiltered = True
                     # filter out copies where either side isn't inside the relative root
                     copy = dict(((dst, src) for (dst, src) in copy.iteritems()
                                  if dst.startswith(relroot)
                                  and src.startswith(relroot)))
                 modifiedset = set(modified)
                 addedset = set(added)
                 removedset = set(removed)
                 for f in modified:
                     if f not in ctx1:
                         # Fix up added, since merged-in additions appear as
                         # modifications during merges
                         modifiedset.remove(f)
                         addedset.add(f)
                 for f in removed:
                     if f not in ctx1:
                         # Merged-in additions that are then removed are reported as removed.
                         # They are not in ctx1, so We don't want to show them in the diff.
                         removedset.remove(f)
                 modified = sorted(modifiedset)
                 added = sorted(addedset)
                 removed = sorted(removedset)
                 for dst, src in list(copy.items()):
                     if src not in ctx1:
                         # Files merged in during a merge and then copied/renamed are
                         # reported as copies. We want to show them in the diff as additions.
                         del copy[dst]
                 def difffn(opts, losedata):
                     return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
                                    copy, getfilectx, opts, losedata, prefix, relroot)
                 if opts.upgrade and not opts.git:
                     try:
                         def losedata(fn):
                             if not losedatafn or not losedatafn(fn=fn):
                                 raise GitDiffRequired
                         # Buffer the whole output until we are sure it can be generated
                         return list(difffn(opts.copy(git=False), losedata))
                     except GitDiffRequired:
                         return difffn(opts.copy(git=True), None)
                 else:
                     return difffn(opts, None)
             def difflabel(func, *args, **kw):
                 '''yields 2-tuples of (output, label) based on the output of func()'''
                 inlinecolor = False
                 if kw.get(r'opts'):
                     inlinecolor = kw[r'opts'].worddiff
                 headprefixes = [('diff', 'diff.diffline'),
                                 ('copy', 'diff.extended'),
                                 ('rename', 'diff.extended'),
                                 ('old', 'diff.extended'),
                                 ('new', 'diff.extended'),
                                 ('deleted', 'diff.extended'),
                                 ('index', 'diff.extended'),
                                 ('similarity', 'diff.extended'),
                                 ('---', 'diff.file_a'),
                                 ('+++', 'diff.file_b')]
                 textprefixes = [('@', 'diff.hunk'),
                                 ('-', 'diff.deleted'),
                                 ('+', 'diff.inserted')]
                 head = False
                 for chunk in func(*args, **kw):
                     lines = chunk.split('\n')
                     matches = {}
                     if inlinecolor:
                         matches = _findmatches(lines)
                     for i, line in enumerate(lines):
                         if i != 0:
                             yield ('\n', '')
                         if head:
                             if line.startswith('@'):
                                 head = False
                         else:
-                            if line and line[0] not in ' +-@\\':
+                            if line and not line.startswith((' ', '+', '-', '@', '\\')):
                                 head = True
                         stripline = line
                         diffline = False
-                        if not head and line and line[0] in '+-':
+                        if not head and line and line.startswith(('+', '-')):
                             # highlight tabs and trailing whitespace, but only in
                             # changed lines
                             stripline = line.rstrip()
                             diffline = True
                         prefixes = textprefixes
                         if head:
                             prefixes = headprefixes
                         for prefix, label in prefixes:
                             if stripline.startswith(prefix):
                                 if diffline:
                                     if i in matches:
                                         for t, l in _inlinediff(lines[i].rstrip(),
                                                                 lines[matches[i]].rstrip(),
                                                                 label):
                                             yield (t, l)
                                     else:
                                         for token in tabsplitter.findall(stripline):
                                             if token.startswith('\t'):
                                                 yield (token, 'diff.tab')
                                             else:
                                                 yield (token, label)
                                 else:
                                     yield (stripline, label)
                                 break
                         else:
                             yield (line, '')
                         if line != stripline:
                             yield (line[len(stripline):], 'diff.trailingwhitespace')
             def _findmatches(slist):
                 '''Look for insertion matches to deletion and returns a dict of
                 correspondences.
                 '''
                 lastmatch = 0
                 matches = {}
                 for i, line in enumerate(slist):
                     if line == '':
                         continue
-                    if line[0] == '-':
+                    if line.startswith('-'):
                         lastmatch = max(lastmatch, i)
                         newgroup = False
                         for j, newline in enumerate(slist[lastmatch + 1:]):
                             if newline == '':
                                 continue
-                            if newline[0] == '-' and newgroup: # too far, no match
+                            if newline.startswith('-') and newgroup: # too far, no match
                                 break
-                            if newline[0] == '+': # potential match
+                            if newline.startswith('+'): # potential match
                                 newgroup = True
                                 sim = difflib.SequenceMatcher(None, line, newline).ratio()
                                 if sim > 0.7:
                                     lastmatch = lastmatch + 1 + j
                                     matches[i] = lastmatch
                                     matches[lastmatch] = i
                                     break
                 return matches
             def _inlinediff(s1, s2, operation):
                 '''Perform string diff to highlight specific changes.'''
-                operation_skip = '+?' if operation == 'diff.deleted' else '-?'
+                operation_skip = ('+', '?') if operation == 'diff.deleted' else ('-', '?')
                 if operation == 'diff.deleted':
                     s2, s1 = s1, s2
                 buff = []
                 # we never want to higlight the leading +-
                 if operation == 'diff.deleted' and s2.startswith('-'):
                     label = operation
                     token = '-'
                     s2 = s2[1:]
                     s1 = s1[1:]
                 elif operation == 'diff.inserted' and s1.startswith('+'):
                     label = operation
                     token = '+'
                     s2 = s2[1:]
                     s1 = s1[1:]
                 else:
                     raise error.ProgrammingError("Case not expected, operation = %s" %
                                                  operation)
                 s = difflib.ndiff(_nonwordre.split(s2), _nonwordre.split(s1))
                 for part in s:
-                    if part[0] in operation_skip or len(part) == 2:
+                    if part.startswith(operation_skip) or len(part) == 2:
                         continue
                     l = operation + '.highlight'
-                    if part[0] in ' ':
+                    if part.startswith(' '):
                         l = operation
                     if part[2:] == '\t':
                         l = 'diff.tab'
                     if l == label: # contiguous token with same label
                         token += part[2:]
                         continue
                     else:
                         buff.append((token, label))
                         label = l
                         token = part[2:]
                 buff.append((token, label))
                 return buff
             def diffui(*args, **kw):
                 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
                 return difflabel(diff, *args, **kw)
             def _filepairs(modified, added, removed, copy, opts):
                 '''generates tuples (f1, f2, copyop), where f1 is the name of the file
                 before and f2 is the the name after. For added files, f1 will be None,
                 and for removed files, f2 will be None. copyop may be set to None, 'copy'
                 or 'rename' (the latter two only if opts.git is set).'''
                 gone = set()
                 copyto = dict([(v, k) for k, v in copy.items()])
                 addedset, removedset = set(added), set(removed)
                 for f in sorted(modified + added + removed):
                     copyop = None
                     f1, f2 = f, f
                     if f in addedset:
                         f1 = None
                         if f in copy:
                             if opts.git:
                                 f1 = copy[f]
                                 if f1 in removedset and f1 not in gone:
                                     copyop = 'rename'
                                     gone.add(f1)
                                 else:
                                     copyop = 'copy'
                     elif f in removedset:
                         f2 = None
                         if opts.git:
                             # have we already reported a copy above?
                             if (f in copyto and copyto[f] in addedset
                                 and copy[copyto[f]] == f):
                                 continue
                     yield f1, f2, copyop
             def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
                         copy, getfilectx, opts, losedatafn, prefix, relroot):
                 '''given input data, generate a diff and yield it in blocks
                 If generating a diff would lose data like flags or binary data and
                 losedatafn is not None, it will be called.
                 relroot is removed and prefix is added to every path in the diff output.
                 If relroot is not empty, this function expects every path in modified,
                 added, removed and copy to start with it.'''
                 def gitindex(text):
                     if not text:
                         text = ""
                     l = len(text)
                     s = hashlib.sha1('blob %d\0' % l)
                     s.update(text)
                     return hex(s.digest())
                 if opts.noprefix:
                     aprefix = bprefix = ''
                 else:
                     aprefix = 'a/'
                     bprefix = 'b/'
                 def diffline(f, revs):
                     revinfo = ' '.join(["-r %s" % rev for rev in revs])
                     return 'diff %s %s' % (revinfo, f)
                 def isempty(fctx):
                     return fctx is None or fctx.size() == 0
                 date1 = dateutil.datestr(ctx1.date())
                 date2 = dateutil.datestr(ctx2.date())
                 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
                 if relroot != '' and (repo.ui.configbool('devel', 'all-warnings')
                                       or repo.ui.configbool('devel', 'check-relroot')):
                     for f in modified + added + removed + list(copy) + list(copy.values()):
                         if f is not None and not f.startswith(relroot):
                             raise AssertionError(
                                 "file %s doesn't start with relroot %s" % (f, relroot))
                 for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):
                     content1 = None
                     content2 = None
                     fctx1 = None
                     fctx2 = None
                     flag1 = None
                     flag2 = None
                     if f1:
                         fctx1 = getfilectx(f1, ctx1)
                         if opts.git or losedatafn:
                             flag1 = ctx1.flags(f1)
                     if f2:
                         fctx2 = getfilectx(f2, ctx2)
                         if opts.git or losedatafn:
                             flag2 = ctx2.flags(f2)
                     # if binary is True, output "summary" or "base85", but not "text diff"
                     if opts.text:
                         binary = False
                     else:
                         binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None)
                     if losedatafn and not opts.git:
                         if (binary or
                             # copy/rename
                             f2 in copy or
                             # empty file creation
                             (not f1 and isempty(fctx2)) or
                             # empty file deletion
                             (isempty(fctx1) and not f2) or
                             # create with flags
                             (not f1 and flag2) or
                             # change flags
                             (f1 and f2 and flag1 != flag2)):
                             losedatafn(f2 or f1)
                     path1 = f1 or f2
                     path2 = f2 or f1
                     path1 = posixpath.join(prefix, path1[len(relroot):])
                     path2 = posixpath.join(prefix, path2[len(relroot):])
                     header = []
                     if opts.git:
                         header.append('diff --git %s%s %s%s' %
                                       (aprefix, path1, bprefix, path2))
                         if not f1: # added
                             header.append('new file mode %s' % gitmode[flag2])
                         elif not f2: # removed
                             header.append('deleted file mode %s' % gitmode[flag1])
                         else:  # modified/copied/renamed
                             mode1, mode2 = gitmode[flag1], gitmode[flag2]
                             if mode1 != mode2:
                                 header.append('old mode %s' % mode1)
                                 header.append('new mode %s' % mode2)
                             if copyop is not None:
                                 if opts.showsimilarity:
                                     sim = similar.score(ctx1[path1], ctx2[path2]) * 100
                                     header.append('similarity index %d%%' % sim)
                                 header.append('%s from %s' % (copyop, path1))
                                 header.append('%s to %s' % (copyop, path2))
                     elif revs and not repo.ui.quiet:
                         header.append(diffline(path1, revs))
                     #  fctx.is  | diffopts                | what to   | is fctx.data()
                     #  binary() | text nobinary git index | output?   | outputted?
                     # ------------------------------------|----------------------------
                     #  yes      | no   no       no  *     | summary   | no
                     #  yes      | no   no       yes *     | base85    | yes
                     #  yes      | no   yes      no  *     | summary   | no
                     #  yes      | no   yes      yes 0     | summary   | no
                     #  yes      | no   yes      yes >0    | summary   | semi [1]
                     #  yes      | yes  *        *   *     | text diff | yes
                     #  no       | *    *        *   *     | text diff | yes
                     # [1]: hash(fctx.data()) is outputted. so fctx.data() cannot be faked
                     if binary and (not opts.git or (opts.git and opts.nobinary and not
                                                     opts.index)):
                         # fast path: no binary content will be displayed, content1 and
                         # content2 are only used for equivalent test. cmp() could have a
                         # fast path.
                         if fctx1 is not None:
                             content1 = b'\0'
                         if fctx2 is not None:
                             if fctx1 is not None and not fctx1.cmp(fctx2):
                                 content2 = b'\0' # not different
                             else:
                                 content2 = b'\0\0'
                     else:
                         # normal path: load contents
                         if fctx1 is not None:
                             content1 = fctx1.data()
                         if fctx2 is not None:
                             content2 = fctx2.data()
                     if binary and opts.git and not opts.nobinary:
                         text = mdiff.b85diff(content1, content2)
                         if text:
                             header.append('index %s..%s' %
                                           (gitindex(content1), gitindex(content2)))
                         hunks = (None, [text]),
                     else:
                         if opts.git and opts.index > 0:
                             flag = flag1
                             if flag is None:
                                 flag = flag2
                             header.append('index %s..%s %s' %
                                           (gitindex(content1)[0:opts.index],
                                            gitindex(content2)[0:opts.index],
                                            gitmode[flag]))
                         uheaders, hunks = mdiff.unidiff(content1, date1,
                                                         content2, date2,
                                                         path1, path2,
                                                         binary=binary, opts=opts)
                         header.extend(uheaders)
                     yield fctx1, fctx2, header, hunks
             def diffstatsum(stats):
                 maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
                 for f, a, r, b in stats:
                     maxfile = max(maxfile, encoding.colwidth(f))
                     maxtotal = max(maxtotal, a + r)
                     addtotal += a
                     removetotal += r
                     binary = binary or b
                 return maxfile, maxtotal, addtotal, removetotal, binary
             def diffstatdata(lines):
                 diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
                 results = []
                 filename, adds, removes, isbinary = None, 0, 0, False
                 def addresult():
                     if filename:
                         results.append((filename, adds, removes, isbinary))
                 # inheader is used to track if a line is in the
                 # header portion of the diff.  This helps properly account
                 # for lines that start with '--' or '++'
                 inheader = False
                 for line in lines:
                     if line.startswith('diff'):
                         addresult()
                         # starting a new file diff
                         # set numbers to 0 and reset inheader
                         inheader = True
                         adds, removes, isbinary = 0, 0, False
                         if line.startswith('diff --git a/'):
                             filename = gitre.search(line).group(2)
                         elif line.startswith('diff -r'):
                             # format: "diff -r ... -r ... filename"
                             filename = diffre.search(line).group(1)
                     elif line.startswith('@@'):
                         inheader = False
                     elif line.startswith('+') and not inheader:
                         adds += 1
                     elif line.startswith('-') and not inheader:
                         removes += 1
                     elif (line.startswith('GIT binary patch') or
                           line.startswith('Binary file')):
                         isbinary = True
                 addresult()
                 return results
             def diffstat(lines, width=80):
                 output = []
                 stats = diffstatdata(lines)
                 maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
                 countwidth = len(str(maxtotal))
                 if hasbinary and countwidth < 3:
                     countwidth = 3
                 graphwidth = width - countwidth - maxname - 6
                 if graphwidth < 10:
                     graphwidth = 10
                 def scale(i):
                     if maxtotal <= graphwidth:
                         return i
                     # If diffstat runs out of room it doesn't print anything,
                     # which isn't very useful, so always print at least one + or -
                     # if there were at least some changes.
                     return max(i * graphwidth // maxtotal, int(bool(i)))
                 for filename, adds, removes, isbinary in stats:
                     if isbinary:
                         count = 'Bin'
                     else:
                         count = '%d' % (adds + removes)
                     pluses = '+' * scale(adds)
                     minuses = '-' * scale(removes)
                     output.append(' %s%s |  %*s %s%s\n' %
                                   (filename, ' ' * (maxname - encoding.colwidth(filename)),
                                    countwidth, count, pluses, minuses))
                 if stats:
                     output.append(_(' %d files changed, %d insertions(+), '
                                     '%d deletions(-)\n')
                                   % (len(stats), totaladds, totalremoves))
                 return ''.join(output)
             def diffstatui(*args, **kw):
                 '''like diffstat(), but yields 2-tuples of (output, label) for
                 ui.write()
                 '''
                 for line in diffstat(*args, **kw).splitlines():
                     if line and line[-1] in '+-':
                         name, graph = line.rsplit(' ', 1)
                         yield (name + ' ', '')
                         m = re.search(br'\++', graph)
                         if m:
                             yield (m.group(0), 'diffstat.inserted')
                         m = re.search(br'-+', graph)
                         if m:
                             yield (m.group(0), 'diffstat.deleted')
                     else:
                         yield (line, '')
                     yield ('\n', '')