upstream/mercurial-mirror Commit - r40262:0d403e9f

1

# ui.py - user interface bits for mercurial

1

# ui.py - user interface bits for mercurial

2

#

2

#

3

4

#

4

#

5

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

5

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

6

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

6

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

7

8

from __future__ import absolute_import

8

from __future__ import absolute_import

9

10

import collections

10

import collections

11

import contextlib

11

import contextlib

12

import errno

12

import errno

13

import getpass

13

import getpass

14

import inspect

14

import inspect

15

import os

15

import os

16

import re

16

import re

17

import signal

17

import signal

18

import socket

18

import socket

19

import subprocess

19

import subprocess

20

import sys

20

import sys

21

import traceback

21

import traceback

22

23

from .i18n import _

23

from .i18n import _

24

from .node import hex

24

from .node import hex

25

26

from . import (

26

from . import (

27

color,

27

color,

28

config,

28

config,

29

configitems,

29

configitems,

30

encoding,

30

encoding,

31

error,

31

error,

32

formatter,

32

formatter,

33

progress,

33

progress,

34

pycompat,

34

pycompat,

35

rcutil,

35

rcutil,

36

scmutil,

36

scmutil,

37

util,

37

util,

38

)

38

)

39

from .utils import (

39

from .utils import (

40

dateutil,

40

dateutil,

41

procutil,

41

procutil,

42

stringutil,

42

stringutil,

43

)

43

)

44

45

urlreq = util.urlreq

45

urlreq = util.urlreq

46

47

# for use with str.translate(None, _keepalnum), to keep just alphanumerics

47

# for use with str.translate(None, _keepalnum), to keep just alphanumerics

48

_keepalnum = ''.join(c for c in map(pycompat.bytechr, range(256))

48

_keepalnum = ''.join(c for c in map(pycompat.bytechr, range(256))

49

if not c.isalnum())

49

if not c.isalnum())

50

51

# The config knobs that will be altered (if unset) by ui.tweakdefaults.

51

# The config knobs that will be altered (if unset) by ui.tweakdefaults.

52

tweakrc = b"""

52

tweakrc = b"""

53

[ui]

53

[ui]

54

# The rollback command is dangerous. As a rule, don't use it.

54

# The rollback command is dangerous. As a rule, don't use it.

55

rollback = False

55

rollback = False

56

# Make `hg status` report copy information

56

# Make `hg status` report copy information

57

statuscopies = yes

57

statuscopies = yes

58

# Prefer curses UIs when available. Revert to plain-text with `text`.

58

# Prefer curses UIs when available. Revert to plain-text with `text`.

59

interface = curses

59

interface = curses

60

61

[commands]

61

[commands]

62

# Grep working directory by default.

62

# Grep working directory by default.

63

grep.all-files = True

63

grep.all-files = True

64

# Make `hg status` emit cwd-relative paths by default.

64

# Make `hg status` emit cwd-relative paths by default.

65

status.relative = yes

65

status.relative = yes

66

# Refuse to perform an `hg update` that would cause a file content merge

66

# Refuse to perform an `hg update` that would cause a file content merge

67

update.check = noconflict

67

update.check = noconflict

68

# Show conflicts information in `hg status`

68

# Show conflicts information in `hg status`

69

status.verbose = True

69

status.verbose = True

70

# Refuse to perform `hg resolve --mark` on files that still have conflict

70

# Refuse to perform `hg resolve --mark` on files that still have conflict

71

# markers

71

# markers

72

resolve.mark-check = abort

72

resolve.mark-check = abort

73

74

[diff]

74

[diff]

75

git = 1

75

git = 1

76

showfunc = 1

76

showfunc = 1

77

word-diff = 1

77

word-diff = 1

78

"""

78

"""

79

80

samplehgrcs = {

80

samplehgrcs = {

81

'user':

81

'user':

82

b"""# example user config (see 'hg help config' for more info)

82

b"""# example user config (see 'hg help config' for more info)

83

[ui]

83

[ui]

84

# name and email, e.g.

84

# name and email, e.g.

85

# username = Jane Doe <jdoe@example.com>

85

# username = Jane Doe <jdoe@example.com>

86

username =

86

username =

87

88

# We recommend enabling tweakdefaults to get slight improvements to

88

# We recommend enabling tweakdefaults to get slight improvements to

89

# the UI over time. Make sure to set HGPLAIN in the environment when

89

# the UI over time. Make sure to set HGPLAIN in the environment when

90

# writing scripts!

90

# writing scripts!

91

# tweakdefaults = True

91

# tweakdefaults = True

92

93

# uncomment to disable color in command output

93

# uncomment to disable color in command output

94

# (see 'hg help color' for details)

94

# (see 'hg help color' for details)

95

# color = never

95

# color = never

96

97

# uncomment to disable command output pagination

97

# uncomment to disable command output pagination

98

# (see 'hg help pager' for details)

98

# (see 'hg help pager' for details)

99

# paginate = never

99

# paginate = never

100

101

[extensions]

101

[extensions]

102

# uncomment these lines to enable some popular extensions

102

# uncomment these lines to enable some popular extensions

103

# (see 'hg help extensions' for more info)

103

# (see 'hg help extensions' for more info)

104

#

104

#

105

# churn =

105

# churn =

106

""",

106

""",

107

108

'cloned':

108

'cloned':

109

b"""# example repository config (see 'hg help config' for more info)

109

b"""# example repository config (see 'hg help config' for more info)

110

[paths]

110

[paths]

111

default = %s

111

default = %s

112

113

# path aliases to other clones of this repo in URLs or filesystem paths

113

# path aliases to other clones of this repo in URLs or filesystem paths

114

# (see 'hg help config.paths' for more info)

114

# (see 'hg help config.paths' for more info)

115

#

115

#

116

# default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork

116

# default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork

117

# my-fork = ssh://jdoe@example.net/hg/jdoes-fork

117

# my-fork = ssh://jdoe@example.net/hg/jdoes-fork

118

# my-clone = /home/jdoe/jdoes-clone

118

# my-clone = /home/jdoe/jdoes-clone

119

120

[ui]

120

[ui]

121

# name and email (local to this repository, optional), e.g.

121

# name and email (local to this repository, optional), e.g.

122

# username = Jane Doe <jdoe@example.com>

122

# username = Jane Doe <jdoe@example.com>

123

""",

123

""",

124

125

'local':

125

'local':

126

b"""# example repository config (see 'hg help config' for more info)

126

b"""# example repository config (see 'hg help config' for more info)

127

[paths]

127

[paths]

128

# path aliases to other clones of this repo in URLs or filesystem paths

128

# path aliases to other clones of this repo in URLs or filesystem paths

129

# (see 'hg help config.paths' for more info)

129

# (see 'hg help config.paths' for more info)

130

#

130

#

131

# default = http://example.com/hg/example-repo

131

# default = http://example.com/hg/example-repo

132

# default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork

132

# default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork

133

# my-fork = ssh://jdoe@example.net/hg/jdoes-fork

133

# my-fork = ssh://jdoe@example.net/hg/jdoes-fork

134

# my-clone = /home/jdoe/jdoes-clone

134

# my-clone = /home/jdoe/jdoes-clone

135

136

[ui]

136

[ui]

137

# name and email (local to this repository, optional), e.g.

137

# name and email (local to this repository, optional), e.g.

138

# username = Jane Doe <jdoe@example.com>

138

# username = Jane Doe <jdoe@example.com>

139

""",

139

""",

140

141

'global':

141

'global':

142

b"""# example system-wide hg config (see 'hg help config' for more info)

142

b"""# example system-wide hg config (see 'hg help config' for more info)

143

144

[ui]

144

[ui]

145

# uncomment to disable color in command output

145

# uncomment to disable color in command output

146

# (see 'hg help color' for details)

146

# (see 'hg help color' for details)

147

# color = never

147

# color = never

148

149

# uncomment to disable command output pagination

149

# uncomment to disable command output pagination

150

# (see 'hg help pager' for details)

150

# (see 'hg help pager' for details)

151

# paginate = never

151

# paginate = never

152

153

[extensions]

153

[extensions]

154

# uncomment these lines to enable some popular extensions

154

# uncomment these lines to enable some popular extensions

155

# (see 'hg help extensions' for more info)

155

# (see 'hg help extensions' for more info)

156

#

156

#

157

# blackbox =

157

# blackbox =

158

# churn =

158

# churn =

159

""",

159

""",

160

}

160

}

161

162

def _maybestrurl(maybebytes):

162

def _maybestrurl(maybebytes):

163

return pycompat.rapply(pycompat.strurl, maybebytes)

163

return pycompat.rapply(pycompat.strurl, maybebytes)

164

165

def _maybebytesurl(maybestr):

165

def _maybebytesurl(maybestr):

166

return pycompat.rapply(pycompat.bytesurl, maybestr)

166

return pycompat.rapply(pycompat.bytesurl, maybestr)

167

168

class httppasswordmgrdbproxy(object):

168

class httppasswordmgrdbproxy(object):

169

"""Delays loading urllib2 until it's needed."""

169

"""Delays loading urllib2 until it's needed."""

170

def __init__(self):

170

def __init__(self):

171

self._mgr = None

171

self._mgr = None

172

173

def _get_mgr(self):

173

def _get_mgr(self):

174

if self._mgr is None:

174

if self._mgr is None:

175

self._mgr = urlreq.httppasswordmgrwithdefaultrealm()

175

self._mgr = urlreq.httppasswordmgrwithdefaultrealm()

176

return self._mgr

176

return self._mgr

177

178

def add_password(self, realm, uris, user, passwd):

178

def add_password(self, realm, uris, user, passwd):

179

return self._get_mgr().add_password(

179

return self._get_mgr().add_password(

180

_maybestrurl(realm), _maybestrurl(uris),

180

_maybestrurl(realm), _maybestrurl(uris),

181

_maybestrurl(user), _maybestrurl(passwd))

181

_maybestrurl(user), _maybestrurl(passwd))

182

183

def find_user_password(self, realm, uri):

183

def find_user_password(self, realm, uri):

184

mgr = self._get_mgr()

184

mgr = self._get_mgr()

185

return _maybebytesurl(mgr.find_user_password(_maybestrurl(realm),

185

return _maybebytesurl(mgr.find_user_password(_maybestrurl(realm),

186

_maybestrurl(uri)))

186

_maybestrurl(uri)))

187

188

def _catchterm(*args):

188

def _catchterm(*args):

189

raise error.SignalInterrupt

189

raise error.SignalInterrupt

190

191

# unique object used to detect no default value has been provided when

191

# unique object used to detect no default value has been provided when

192

# retrieving configuration value.

192

# retrieving configuration value.

193

_unset = object()

193

_unset = object()

194

195

# _reqexithandlers: callbacks run at the end of a request

195

# _reqexithandlers: callbacks run at the end of a request

196

_reqexithandlers = []

196

_reqexithandlers = []

197

198

class ui(object):

198

class ui(object):

199

def __init__(self, src=None):

199

def __init__(self, src=None):

200

"""Create a fresh new ui object if no src given

200

"""Create a fresh new ui object if no src given

201

202

Use uimod.ui.load() to create a ui which knows global and user configs.

202

Use uimod.ui.load() to create a ui which knows global and user configs.

203

In most cases, you should use ui.copy() to create a copy of an existing

203

In most cases, you should use ui.copy() to create a copy of an existing

204

ui object.

204

ui object.

205

"""

205

"""

206

# _buffers: used for temporary capture of output

206

# _buffers: used for temporary capture of output

207

self._buffers = []

207

self._buffers = []

208

# 3-tuple describing how each buffer in the stack behaves.

208

# 3-tuple describing how each buffer in the stack behaves.

209

# Values are (capture stderr, capture subprocesses, apply labels).

209

# Values are (capture stderr, capture subprocesses, apply labels).

210

self._bufferstates = []

210

self._bufferstates = []

211

# When a buffer is active, defines whether we are expanding labels.

211

# When a buffer is active, defines whether we are expanding labels.

212

# This exists to prevent an extra list lookup.

212

# This exists to prevent an extra list lookup.

213

self._bufferapplylabels = None

213

self._bufferapplylabels = None

214

self.quiet = self.verbose = self.debugflag = self.tracebackflag = False

214

self.quiet = self.verbose = self.debugflag = self.tracebackflag = False

215

self._reportuntrusted = True

215

self._reportuntrusted = True

216

self._knownconfig = configitems.coreitems

216

self._knownconfig = configitems.coreitems

217

self._ocfg = config.config() # overlay

217

self._ocfg = config.config() # overlay

218

self._tcfg = config.config() # trusted

218

self._tcfg = config.config() # trusted

219

self._ucfg = config.config() # untrusted

219

self._ucfg = config.config() # untrusted

220

self._trustusers = set()

220

self._trustusers = set()

221

self._trustgroups = set()

221

self._trustgroups = set()

222

self.callhooks = True

222

self.callhooks = True

223

# Insecure server connections requested.

223

# Insecure server connections requested.

224

self.insecureconnections = False

224

self.insecureconnections = False

225

# Blocked time

225

# Blocked time

226

self.logblockedtimes = False

226

self.logblockedtimes = False

227

# color mode: see mercurial/color.py for possible value

227

# color mode: see mercurial/color.py for possible value

228

self._colormode = None

228

self._colormode = None

229

self._terminfoparams = {}

229

self._terminfoparams = {}

230

self._styles = {}

230

self._styles = {}

231

self._uninterruptible = False

231

self._uninterruptible = False

232

233

if src:

233

if src:

234

self.fout = src.fout

234

self.fout = src.fout

235

self.ferr = src.ferr

235

self.ferr = src.ferr

236

self.fin = src.fin

236

self.fin = src.fin

237

self._finoutredirected = src._finoutredirected

237

self._finoutredirected = src._finoutredirected

238

self.pageractive = src.pageractive

238

self.pageractive = src.pageractive

239

self._disablepager = src._disablepager

239

self._disablepager = src._disablepager

240

self._tweaked = src._tweaked

240

self._tweaked = src._tweaked

241

242

self._tcfg = src._tcfg.copy()

242

self._tcfg = src._tcfg.copy()

243

self._ucfg = src._ucfg.copy()

243

self._ucfg = src._ucfg.copy()

244

self._ocfg = src._ocfg.copy()

244

self._ocfg = src._ocfg.copy()

245

self._trustusers = src._trustusers.copy()

245

self._trustusers = src._trustusers.copy()

246

self._trustgroups = src._trustgroups.copy()

246

self._trustgroups = src._trustgroups.copy()

247

self.environ = src.environ

247

self.environ = src.environ

248

self.callhooks = src.callhooks

248

self.callhooks = src.callhooks

249

self.insecureconnections = src.insecureconnections

249

self.insecureconnections = src.insecureconnections

250

self._colormode = src._colormode

250

self._colormode = src._colormode

251

self._terminfoparams = src._terminfoparams.copy()

251

self._terminfoparams = src._terminfoparams.copy()

252

self._styles = src._styles.copy()

252

self._styles = src._styles.copy()

253

254

self.fixconfig()

254

self.fixconfig()

255

256

self.httppasswordmgrdb = src.httppasswordmgrdb

256

self.httppasswordmgrdb = src.httppasswordmgrdb

257

self._blockedtimes = src._blockedtimes

257

self._blockedtimes = src._blockedtimes

258

else:

258

else:

259

self.fout = procutil.stdout

259

self.fout = procutil.stdout

260

self.ferr = procutil.stderr

260

self.ferr = procutil.stderr

261

self.fin = procutil.stdin

261

self.fin = procutil.stdin

262

self._finoutredirected = False

262

self._finoutredirected = False

263

self.pageractive = False

263

self.pageractive = False

264

self._disablepager = False

264

self._disablepager = False

265

self._tweaked = False

265

self._tweaked = False

266

267

# shared read-only environment

267

# shared read-only environment

268

self.environ = encoding.environ

268

self.environ = encoding.environ

269

270

self.httppasswordmgrdb = httppasswordmgrdbproxy()

270

self.httppasswordmgrdb = httppasswordmgrdbproxy()

271

self._blockedtimes = collections.defaultdict(int)

271

self._blockedtimes = collections.defaultdict(int)

272

273

allowed = self.configlist('experimental', 'exportableenviron')

273

allowed = self.configlist('experimental', 'exportableenviron')

274

if '*' in allowed:

274

if '*' in allowed:

275

self._exportableenviron = self.environ

275

self._exportableenviron = self.environ

276

else:

276

else:

277

self._exportableenviron = {}

277

self._exportableenviron = {}

278

for k in allowed:

278

for k in allowed:

279

if k in self.environ:

279

if k in self.environ:

280

self._exportableenviron[k] = self.environ[k]

280

self._exportableenviron[k] = self.environ[k]

281

282

@classmethod

282

@classmethod

283

def load(cls):

283

def load(cls):

284

"""Create a ui and load global and user configs"""

284

"""Create a ui and load global and user configs"""

285

u = cls()

285

u = cls()

286

# we always trust global config files and environment variables

286

# we always trust global config files and environment variables

287

for t, f in rcutil.rccomponents():

287

for t, f in rcutil.rccomponents():

288

if t == 'path':

288

if t == 'path':

289

u.readconfig(f, trust=True)

289

u.readconfig(f, trust=True)

290

elif t == 'items':

290

elif t == 'items':

291

sections = set()

291

sections = set()

292

for section, name, value, source in f:

292

for section, name, value, source in f:

293

# do not set u._ocfg

293

# do not set u._ocfg

294

# XXX clean this up once immutable config object is a thing

294

# XXX clean this up once immutable config object is a thing

295

u._tcfg.set(section, name, value, source)

295

u._tcfg.set(section, name, value, source)

296

u._ucfg.set(section, name, value, source)

296

u._ucfg.set(section, name, value, source)

297

sections.add(section)

297

sections.add(section)

298

for section in sections:

298

for section in sections:

299

u.fixconfig(section=section)

299

u.fixconfig(section=section)

300

else:

300

else:

301

raise error.ProgrammingError('unknown rctype: %s' % t)

301

raise error.ProgrammingError('unknown rctype: %s' % t)

302

u._maybetweakdefaults()

302

u._maybetweakdefaults()

303

return u

303

return u

304

305

def _maybetweakdefaults(self):

305

def _maybetweakdefaults(self):

306

if not self.configbool('ui', 'tweakdefaults'):

306

if not self.configbool('ui', 'tweakdefaults'):

307

return

307

return

308

if self._tweaked or self.plain('tweakdefaults'):

308

if self._tweaked or self.plain('tweakdefaults'):

309

return

309

return

310

311

# Note: it is SUPER IMPORTANT that you set self._tweaked to

311

# Note: it is SUPER IMPORTANT that you set self._tweaked to

312

# True *before* any calls to setconfig(), otherwise you'll get

312

# True *before* any calls to setconfig(), otherwise you'll get

313

# infinite recursion between setconfig and this method.

313

# infinite recursion between setconfig and this method.

314

#

314

#

315

# TODO: We should extract an inner method in setconfig() to

315

# TODO: We should extract an inner method in setconfig() to

316

# avoid this weirdness.

316

# avoid this weirdness.

317

self._tweaked = True

317

self._tweaked = True

318

tmpcfg = config.config()

318

tmpcfg = config.config()

319

tmpcfg.parse('<tweakdefaults>', tweakrc)

319

tmpcfg.parse('<tweakdefaults>', tweakrc)

320

for section in tmpcfg:

320

for section in tmpcfg:

321

for name, value in tmpcfg.items(section):

321

for name, value in tmpcfg.items(section):

322

if not self.hasconfig(section, name):

322

if not self.hasconfig(section, name):

323

self.setconfig(section, name, value, "<tweakdefaults>")

323

self.setconfig(section, name, value, "<tweakdefaults>")

324

325

def copy(self):

325

def copy(self):

326

return self.__class__(self)

326

return self.__class__(self)

327

328

def resetstate(self):

328

def resetstate(self):

329

"""Clear internal state that shouldn't persist across commands"""

329

"""Clear internal state that shouldn't persist across commands"""

330

if self._progbar:

330

if self._progbar:

331

self._progbar.resetstate() # reset last-print time of progress bar

331

self._progbar.resetstate() # reset last-print time of progress bar

332

self.httppasswordmgrdb = httppasswordmgrdbproxy()

332

self.httppasswordmgrdb = httppasswordmgrdbproxy()

333

334

@contextlib.contextmanager

334

@contextlib.contextmanager

335

def timeblockedsection(self, key):

335

def timeblockedsection(self, key):

336

# this is open-coded below - search for timeblockedsection to find them

336

# this is open-coded below - search for timeblockedsection to find them

337

starttime = util.timer()

337

starttime = util.timer()

338

try:

338

try:

339

yield

339

yield

340

finally:

340

finally:

341

self._blockedtimes[key + '_blocked'] += \

341

self._blockedtimes[key + '_blocked'] += \

342

(util.timer() - starttime) * 1000

342

(util.timer() - starttime) * 1000

343

344

@contextlib.contextmanager

344

@contextlib.contextmanager

345

def uninterruptable(self):

345

def uninterruptable(self):

346

"""Mark an operation as unsafe.

346

"""Mark an operation as unsafe.

347

348

Most operations on a repository are safe to interrupt, but a

348

Most operations on a repository are safe to interrupt, but a

349

few are risky (for example repair.strip). This context manager

349

few are risky (for example repair.strip). This context manager

350

lets you advise Mercurial that something risky is happening so

350

lets you advise Mercurial that something risky is happening so

351

that control-C etc can be blocked if desired.

351

that control-C etc can be blocked if desired.

352

"""

352

"""

353

enabled = self.configbool('experimental', 'nointerrupt')

353

enabled = self.configbool('experimental', 'nointerrupt')

354

if (enabled and

354

if (enabled and

355

self.configbool('experimental', 'nointerrupt-interactiveonly')):

355

self.configbool('experimental', 'nointerrupt-interactiveonly')):

356

enabled = self.interactive()

356

enabled = self.interactive()

357

if self._uninterruptible or not enabled:

357

if self._uninterruptible or not enabled:

358

# if nointerrupt support is turned off, the process isn't

358

# if nointerrupt support is turned off, the process isn't

359

# interactive, or we're already in an uninterruptable

359

# interactive, or we're already in an uninterruptable

360

# block, do nothing.

360

# block, do nothing.

361

yield

361

yield

362

return

362

return

363

def warn():

363

def warn():

364

self.warn(_("shutting down cleanly\n"))

364

self.warn(_("shutting down cleanly\n"))

365

self.warn(

365

self.warn(

366

_("press ^C again to terminate immediately (dangerous)\n"))

366

_("press ^C again to terminate immediately (dangerous)\n"))

367

return True

367

return True

368

with procutil.uninterruptable(warn):

368

with procutil.uninterruptable(warn):

369

try:

369

try:

370

self._uninterruptible = True

370

self._uninterruptible = True

371

yield

371

yield

372

finally:

372

finally:

373

self._uninterruptible = False

373

self._uninterruptible = False

374

375

def formatter(self, topic, opts):

375

def formatter(self, topic, opts):

376

return formatter.formatter(self, self, topic, opts)

376

return formatter.formatter(self, self, topic, opts)

377

378

def _trusted(self, fp, f):

378

def _trusted(self, fp, f):

379

st = util.fstat(fp)

379

st = util.fstat(fp)

380

if util.isowner(st):

380

if util.isowner(st):

381

return True

381

return True

382

383

tusers, tgroups = self._trustusers, self._trustgroups

383

tusers, tgroups = self._trustusers, self._trustgroups

384

if '*' in tusers or '*' in tgroups:

384

if '*' in tusers or '*' in tgroups:

385

return True

385

return True

386

387

user = util.username(st.st_uid)

387

user = util.username(st.st_uid)

388

group = util.groupname(st.st_gid)

388

group = util.groupname(st.st_gid)

389

if user in tusers or group in tgroups or user == util.username():

389

if user in tusers or group in tgroups or user == util.username():

390

return True

390

return True

391

392

if self._reportuntrusted:

392

if self._reportuntrusted:

393

self.warn(_('not trusting file %s from untrusted '

393

self.warn(_('not trusting file %s from untrusted '

394

'user %s, group %s\n') % (f, user, group))

394

'user %s, group %s\n') % (f, user, group))

395

return False

395

return False

396

397

def readconfig(self, filename, root=None, trust=False,

397

def readconfig(self, filename, root=None, trust=False,

398

sections=None, remap=None):

398

sections=None, remap=None):

399

try:

399

try:

400

fp = open(filename, r'rb')

400

fp = open(filename, r'rb')

401

except IOError:

401

except IOError:

402

if not sections: # ignore unless we were looking for something

402

if not sections: # ignore unless we were looking for something

403

return

403

return

404

raise

404

raise

405

406

cfg = config.config()

406

cfg = config.config()

407

trusted = sections or trust or self._trusted(fp, filename)

407

trusted = sections or trust or self._trusted(fp, filename)

408

409

try:

409

try:

410

cfg.read(filename, fp, sections=sections, remap=remap)

410

cfg.read(filename, fp, sections=sections, remap=remap)

411

fp.close()

411

fp.close()

412

except error.ConfigError as inst:

412

except error.ConfigError as inst:

413

if trusted:

413

if trusted:

414

raise

414

raise

415

self.warn(_("ignored: %s\n") % stringutil.forcebytestr(inst))

415

self.warn(_("ignored: %s\n") % stringutil.forcebytestr(inst))

416

417

if self.plain():

417

if self.plain():

418

for k in ('debug', 'fallbackencoding', 'quiet', 'slash',

418

for k in ('debug', 'fallbackencoding', 'quiet', 'slash',

419

'logtemplate', 'statuscopies', 'style',

419

'logtemplate', 'statuscopies', 'style',

420

'traceback', 'verbose'):

420

'traceback', 'verbose'):

421

if k in cfg['ui']:

421

if k in cfg['ui']:

422

del cfg['ui'][k]

422

del cfg['ui'][k]

423

for k, v in cfg.items('defaults'):

423

for k, v in cfg.items('defaults'):

424

del cfg['defaults'][k]

424

del cfg['defaults'][k]

425

for k, v in cfg.items('commands'):

425

for k, v in cfg.items('commands'):

426

del cfg['commands'][k]

426

del cfg['commands'][k]

427

# Don't remove aliases from the configuration if in the exceptionlist

427

# Don't remove aliases from the configuration if in the exceptionlist

428

if self.plain('alias'):

428

if self.plain('alias'):

429

for k, v in cfg.items('alias'):

429

for k, v in cfg.items('alias'):

430

del cfg['alias'][k]

430

del cfg['alias'][k]

431

if self.plain('revsetalias'):

431

if self.plain('revsetalias'):

432

for k, v in cfg.items('revsetalias'):

432

for k, v in cfg.items('revsetalias'):

433

del cfg['revsetalias'][k]

433

del cfg['revsetalias'][k]

434

if self.plain('templatealias'):

434

if self.plain('templatealias'):

435

for k, v in cfg.items('templatealias'):

435

for k, v in cfg.items('templatealias'):

436

del cfg['templatealias'][k]

436

del cfg['templatealias'][k]

437

438

if trusted:

438

if trusted:

439

self._tcfg.update(cfg)

439

self._tcfg.update(cfg)

440

self._tcfg.update(self._ocfg)

440

self._tcfg.update(self._ocfg)

441

self._ucfg.update(cfg)

441

self._ucfg.update(cfg)

442

self._ucfg.update(self._ocfg)

442

self._ucfg.update(self._ocfg)

443

444

if root is None:

444

if root is None:

445

root = os.path.expanduser('~')

445

root = os.path.expanduser('~')

446

self.fixconfig(root=root)

446

self.fixconfig(root=root)

447

448

def fixconfig(self, root=None, section=None):

448

def fixconfig(self, root=None, section=None):

449

if section in (None, 'paths'):

449

if section in (None, 'paths'):

450

# expand vars and ~

450

# expand vars and ~

451

# translate paths relative to root (or home) into absolute paths

451

# translate paths relative to root (or home) into absolute paths

452

root = root or encoding.getcwd()

452

root = root or encoding.getcwd()

453

for c in self._tcfg, self._ucfg, self._ocfg:

453

for c in self._tcfg, self._ucfg, self._ocfg:

454

for n, p in c.items('paths'):

454

for n, p in c.items('paths'):

455

# Ignore sub-options.

455

# Ignore sub-options.

456

if ':' in n:

456

if ':' in n:

457

continue

457

continue

458

if not p:

458

if not p:

459

continue

459

continue

460

if '%%' in p:

460

if '%%' in p:

461

s = self.configsource('paths', n) or 'none'

461

s = self.configsource('paths', n) or 'none'

462

self.warn(_("(deprecated '%%' in path %s=%s from %s)\n")

462

self.warn(_("(deprecated '%%' in path %s=%s from %s)\n")

463

% (n, p, s))

463

% (n, p, s))

464

p = p.replace('%%', '%')

464

p = p.replace('%%', '%')

465

p = util.expandpath(p)

465

p = util.expandpath(p)

466

if not util.hasscheme(p) and not os.path.isabs(p):

466

if not util.hasscheme(p) and not os.path.isabs(p):

467

p = os.path.normpath(os.path.join(root, p))

467

p = os.path.normpath(os.path.join(root, p))

468

c.set("paths", n, p)

468

c.set("paths", n, p)

469

470

if section in (None, 'ui'):

470

if section in (None, 'ui'):

471

# update ui options

471

# update ui options

472

self.debugflag = self.configbool('ui', 'debug')

472

self.debugflag = self.configbool('ui', 'debug')

473

self.verbose = self.debugflag or self.configbool('ui', 'verbose')

473

self.verbose = self.debugflag or self.configbool('ui', 'verbose')

474

self.quiet = not self.debugflag and self.configbool('ui', 'quiet')

474

self.quiet = not self.debugflag and self.configbool('ui', 'quiet')

475

if self.verbose and self.quiet:

475

if self.verbose and self.quiet:

476

self.quiet = self.verbose = False

476

self.quiet = self.verbose = False

477

self._reportuntrusted = self.debugflag or self.configbool("ui",

477

self._reportuntrusted = self.debugflag or self.configbool("ui",

478

"report_untrusted")

478

"report_untrusted")

479

self.tracebackflag = self.configbool('ui', 'traceback')

479

self.tracebackflag = self.configbool('ui', 'traceback')

480

self.logblockedtimes = self.configbool('ui', 'logblockedtimes')

480

self.logblockedtimes = self.configbool('ui', 'logblockedtimes')

481

482

if section in (None, 'trusted'):

482

if section in (None, 'trusted'):

483

# update trust information

483

# update trust information

484

self._trustusers.update(self.configlist('trusted', 'users'))

484

self._trustusers.update(self.configlist('trusted', 'users'))

485

self._trustgroups.update(self.configlist('trusted', 'groups'))

485

self._trustgroups.update(self.configlist('trusted', 'groups'))

486

487

def backupconfig(self, section, item):

487

def backupconfig(self, section, item):

488

return (self._ocfg.backup(section, item),

488

return (self._ocfg.backup(section, item),

489

self._tcfg.backup(section, item),

489

self._tcfg.backup(section, item),

490

self._ucfg.backup(section, item),)

490

self._ucfg.backup(section, item),)

491

def restoreconfig(self, data):

491

def restoreconfig(self, data):

492

self._ocfg.restore(data[0])

492

self._ocfg.restore(data[0])

493

self._tcfg.restore(data[1])

493

self._tcfg.restore(data[1])

494

self._ucfg.restore(data[2])

494

self._ucfg.restore(data[2])

495

496

def setconfig(self, section, name, value, source=''):

496

def setconfig(self, section, name, value, source=''):

497

for cfg in (self._ocfg, self._tcfg, self._ucfg):

497

for cfg in (self._ocfg, self._tcfg, self._ucfg):

498

cfg.set(section, name, value, source)

498

cfg.set(section, name, value, source)

499

self.fixconfig(section=section)

499

self.fixconfig(section=section)

500

self._maybetweakdefaults()

500

self._maybetweakdefaults()

501

502

def _data(self, untrusted):

502

def _data(self, untrusted):

503

return untrusted and self._ucfg or self._tcfg

503

return untrusted and self._ucfg or self._tcfg

504

505

def configsource(self, section, name, untrusted=False):

505

def configsource(self, section, name, untrusted=False):

506

return self._data(untrusted).source(section, name)

506

return self._data(untrusted).source(section, name)

507

508

def config(self, section, name, default=_unset, untrusted=False):

508

def config(self, section, name, default=_unset, untrusted=False):

509

"""return the plain string version of a config"""

509

"""return the plain string version of a config"""

510

value = self._config(section, name, default=default,

510

value = self._config(section, name, default=default,

511

untrusted=untrusted)

511

untrusted=untrusted)

512

if value is _unset:

512

if value is _unset:

513

return None

513

return None

514

return value

514

return value

515

516

def _config(self, section, name, default=_unset, untrusted=False):

516

def _config(self, section, name, default=_unset, untrusted=False):

517

value = itemdefault = default

517

value = itemdefault = default

518

item = self._knownconfig.get(section, {}).get(name)

518

item = self._knownconfig.get(section, {}).get(name)

519

alternates = [(section, name)]

519

alternates = [(section, name)]

520

521

if item is not None:

521

if item is not None:

522

alternates.extend(item.alias)

522

alternates.extend(item.alias)

523

if callable(item.default):

523

if callable(item.default):

524

itemdefault = item.default()

524

itemdefault = item.default()

525

else:

525

else:

526

itemdefault = item.default

526

itemdefault = item.default

527

else:

527

else:

528

msg = ("accessing unregistered config item: '%s.%s'")

528

msg = ("accessing unregistered config item: '%s.%s'")

529

msg %= (section, name)

529

msg %= (section, name)

530

self.develwarn(msg, 2, 'warn-config-unknown')

530

self.develwarn(msg, 2, 'warn-config-unknown')

531

532

if default is _unset:

532

if default is _unset:

533

if item is None:

533

if item is None:

534

value = default

534

value = default

535

elif item.default is configitems.dynamicdefault:

535

elif item.default is configitems.dynamicdefault:

536

value = None

536

value = None

537

msg = "config item requires an explicit default value: '%s.%s'"

537

msg = "config item requires an explicit default value: '%s.%s'"

538

msg %= (section, name)

538

msg %= (section, name)

539

self.develwarn(msg, 2, 'warn-config-default')

539

self.develwarn(msg, 2, 'warn-config-default')

540

else:

540

else:

541

value = itemdefault

541

value = itemdefault

542

elif (item is not None

542

elif (item is not None

543

and item.default is not configitems.dynamicdefault

543

and item.default is not configitems.dynamicdefault

544

and default != itemdefault):

544

and default != itemdefault):

545

msg = ("specifying a mismatched default value for a registered "

545

msg = ("specifying a mismatched default value for a registered "

546

"config item: '%s.%s' '%s'")

546

"config item: '%s.%s' '%s'")

547

msg %= (section, name, pycompat.bytestr(default))

547

msg %= (section, name, pycompat.bytestr(default))

548

self.develwarn(msg, 2, 'warn-config-default')

548

self.develwarn(msg, 2, 'warn-config-default')

549

550

for s, n in alternates:

550

for s, n in alternates:

551

candidate = self._data(untrusted).get(s, n, None)

551

candidate = self._data(untrusted).get(s, n, None)

552

if candidate is not None:

552

if candidate is not None:

553

value = candidate

553

value = candidate

554

section = s

554

section = s

555

name = n

555

name = n

556

break

556

break

557

558

if self.debugflag and not untrusted and self._reportuntrusted:

558

if self.debugflag and not untrusted and self._reportuntrusted:

559

for s, n in alternates:

559

for s, n in alternates:

560

uvalue = self._ucfg.get(s, n)

560

uvalue = self._ucfg.get(s, n)

561

if uvalue is not None and uvalue != value:

561

if uvalue is not None and uvalue != value:

562

self.debug("ignoring untrusted configuration option "

562

self.debug("ignoring untrusted configuration option "

563

"%s.%s = %s\n" % (s, n, uvalue))

563

"%s.%s = %s\n" % (s, n, uvalue))

564

return value

564

return value

565

566

def configsuboptions(self, section, name, default=_unset, untrusted=False):

566

def configsuboptions(self, section, name, default=_unset, untrusted=False):

567

"""Get a config option and all sub-options.

567

"""Get a config option and all sub-options.

568

569

Some config options have sub-options that are declared with the

569

Some config options have sub-options that are declared with the

570

format "key:opt = value". This method is used to return the main

570

format "key:opt = value". This method is used to return the main

571

option and all its declared sub-options.

571

option and all its declared sub-options.

572

573

Returns a 2-tuple of ``(option, sub-options)``, where `sub-options``

573

Returns a 2-tuple of ``(option, sub-options)``, where `sub-options``

574

is a dict of defined sub-options where keys and values are strings.

574

is a dict of defined sub-options where keys and values are strings.

575

"""

575

"""

576

main = self.config(section, name, default, untrusted=untrusted)

576

main = self.config(section, name, default, untrusted=untrusted)

577

data = self._data(untrusted)

577

data = self._data(untrusted)

578

sub = {}

578

sub = {}

579

prefix = '%s:' % name

579

prefix = '%s:' % name

580

for k, v in data.items(section):

580

for k, v in data.items(section):

581

if k.startswith(prefix):

581

if k.startswith(prefix):

582

sub[k[len(prefix):]] = v

582

sub[k[len(prefix):]] = v

583

584

if self.debugflag and not untrusted and self._reportuntrusted:

584

if self.debugflag and not untrusted and self._reportuntrusted:

585

for k, v in sub.items():

585

for k, v in sub.items():

586

uvalue = self._ucfg.get(section, '%s:%s' % (name, k))

586

uvalue = self._ucfg.get(section, '%s:%s' % (name, k))

587

if uvalue is not None and uvalue != v:

587

if uvalue is not None and uvalue != v:

588

self.debug('ignoring untrusted configuration option '

588

self.debug('ignoring untrusted configuration option '

589

'%s:%s.%s = %s\n' % (section, name, k, uvalue))

589

'%s:%s.%s = %s\n' % (section, name, k, uvalue))

590

591

return main, sub

591

return main, sub

592

593

def configpath(self, section, name, default=_unset, untrusted=False):

593

def configpath(self, section, name, default=_unset, untrusted=False):

594

'get a path config item, expanded relative to repo root or config file'

594

'get a path config item, expanded relative to repo root or config file'

595

v = self.config(section, name, default, untrusted)

595

v = self.config(section, name, default, untrusted)

596

if v is None:

596

if v is None:

597

return None

597

return None

598

if not os.path.isabs(v) or "://" not in v:

598

if not os.path.isabs(v) or "://" not in v:

599

src = self.configsource(section, name, untrusted)

599

src = self.configsource(section, name, untrusted)

600

if ':' in src:

600

if ':' in src:

601

base = os.path.dirname(src.rsplit(':')[0])

601

base = os.path.dirname(src.rsplit(':')[0])

602

v = os.path.join(base, os.path.expanduser(v))

602

v = os.path.join(base, os.path.expanduser(v))

603

return v

603

return v

604

605

def configbool(self, section, name, default=_unset, untrusted=False):

605

def configbool(self, section, name, default=_unset, untrusted=False):

606

"""parse a configuration element as a boolean

606

"""parse a configuration element as a boolean

607

608

>>> u = ui(); s = b'foo'

608

>>> u = ui(); s = b'foo'

609

>>> u.setconfig(s, b'true', b'yes')

609

>>> u.setconfig(s, b'true', b'yes')

610

>>> u.configbool(s, b'true')

610

>>> u.configbool(s, b'true')

611

True

611

True

612

>>> u.setconfig(s, b'false', b'no')

612

>>> u.setconfig(s, b'false', b'no')

613

>>> u.configbool(s, b'false')

613

>>> u.configbool(s, b'false')

614

False

614

False

615

>>> u.configbool(s, b'unknown')

615

>>> u.configbool(s, b'unknown')

616

False

616

False

617

>>> u.configbool(s, b'unknown', True)

617

>>> u.configbool(s, b'unknown', True)

618

True

618

True

619

>>> u.setconfig(s, b'invalid', b'somevalue')

619

>>> u.setconfig(s, b'invalid', b'somevalue')

620

>>> u.configbool(s, b'invalid')

620

>>> u.configbool(s, b'invalid')

621

Traceback (most recent call last):

621

Traceback (most recent call last):

622

...

622

...

623

ConfigError: foo.invalid is not a boolean ('somevalue')

623

ConfigError: foo.invalid is not a boolean ('somevalue')

624

"""

624

"""

625

626

v = self._config(section, name, default, untrusted=untrusted)

626

v = self._config(section, name, default, untrusted=untrusted)

627

if v is None:

627

if v is None:

628

return v

628

return v

629

if v is _unset:

629

if v is _unset:

630

if default is _unset:

630

if default is _unset:

631

return False

631

return False

632

return default

632

return default

633

if isinstance(v, bool):

633

if isinstance(v, bool):

634

return v

634

return v

635

b = stringutil.parsebool(v)

635

b = stringutil.parsebool(v)

636

if b is None:

636

if b is None:

637

raise error.ConfigError(_("%s.%s is not a boolean ('%s')")

637

raise error.ConfigError(_("%s.%s is not a boolean ('%s')")

638

% (section, name, v))

638

% (section, name, v))

639

return b

639

return b

640

641

def configwith(self, convert, section, name, default=_unset,

641

def configwith(self, convert, section, name, default=_unset,

642

desc=None, untrusted=False):

642

desc=None, untrusted=False):

643

"""parse a configuration element with a conversion function

643

"""parse a configuration element with a conversion function

644

645

>>> u = ui(); s = b'foo'

645

>>> u = ui(); s = b'foo'

646

>>> u.setconfig(s, b'float1', b'42')

646

>>> u.setconfig(s, b'float1', b'42')

647

>>> u.configwith(float, s, b'float1')

647

>>> u.configwith(float, s, b'float1')

648

42.0

648

42.0

649

>>> u.setconfig(s, b'float2', b'-4.25')

649

>>> u.setconfig(s, b'float2', b'-4.25')

650

>>> u.configwith(float, s, b'float2')

650

>>> u.configwith(float, s, b'float2')

651

-4.25

651

-4.25

652

>>> u.configwith(float, s, b'unknown', 7)

652

>>> u.configwith(float, s, b'unknown', 7)

653

7.0

653

7.0

654

>>> u.setconfig(s, b'invalid', b'somevalue')

654

>>> u.setconfig(s, b'invalid', b'somevalue')

655

>>> u.configwith(float, s, b'invalid')

655

>>> u.configwith(float, s, b'invalid')

656

Traceback (most recent call last):

656

Traceback (most recent call last):

657

...

657

...

658

ConfigError: foo.invalid is not a valid float ('somevalue')

658

ConfigError: foo.invalid is not a valid float ('somevalue')

659

>>> u.configwith(float, s, b'invalid', desc=b'womble')

659

>>> u.configwith(float, s, b'invalid', desc=b'womble')

660

Traceback (most recent call last):

660

Traceback (most recent call last):

661

...

661

...

662

ConfigError: foo.invalid is not a valid womble ('somevalue')

662

ConfigError: foo.invalid is not a valid womble ('somevalue')

663

"""

663

"""

664

665

v = self.config(section, name, default, untrusted)

665

v = self.config(section, name, default, untrusted)

666

if v is None:

666

if v is None:

667

return v # do not attempt to convert None

667

return v # do not attempt to convert None

668

try:

668

try:

669

return convert(v)

669

return convert(v)

670

except (ValueError, error.ParseError):

670

except (ValueError, error.ParseError):

671

if desc is None:

671

if desc is None:

672

desc = pycompat.sysbytes(convert.__name__)

672

desc = pycompat.sysbytes(convert.__name__)

673

raise error.ConfigError(_("%s.%s is not a valid %s ('%s')")

673

raise error.ConfigError(_("%s.%s is not a valid %s ('%s')")

674

% (section, name, desc, v))

674

% (section, name, desc, v))

675

676

def configint(self, section, name, default=_unset, untrusted=False):

676

def configint(self, section, name, default=_unset, untrusted=False):

677

"""parse a configuration element as an integer

677

"""parse a configuration element as an integer

678

679

>>> u = ui(); s = b'foo'

679

>>> u = ui(); s = b'foo'

680

>>> u.setconfig(s, b'int1', b'42')

680

>>> u.setconfig(s, b'int1', b'42')

681

>>> u.configint(s, b'int1')

681

>>> u.configint(s, b'int1')

682

42

682

42

683

>>> u.setconfig(s, b'int2', b'-42')

683

>>> u.setconfig(s, b'int2', b'-42')

684

>>> u.configint(s, b'int2')

684

>>> u.configint(s, b'int2')

685

-42

685

-42

686

>>> u.configint(s, b'unknown', 7)

686

>>> u.configint(s, b'unknown', 7)

687

7

687

7

688

>>> u.setconfig(s, b'invalid', b'somevalue')

688

>>> u.setconfig(s, b'invalid', b'somevalue')

689

>>> u.configint(s, b'invalid')

689

>>> u.configint(s, b'invalid')

690

Traceback (most recent call last):

690

Traceback (most recent call last):

691

...

691

...

692

ConfigError: foo.invalid is not a valid integer ('somevalue')

692

ConfigError: foo.invalid is not a valid integer ('somevalue')

693

"""

693

"""

694

695

return self.configwith(int, section, name, default, 'integer',

695

return self.configwith(int, section, name, default, 'integer',

696

untrusted)

696

untrusted)

697

698

def configbytes(self, section, name, default=_unset, untrusted=False):

698

def configbytes(self, section, name, default=_unset, untrusted=False):

699

"""parse a configuration element as a quantity in bytes

699

"""parse a configuration element as a quantity in bytes

700

701

Units can be specified as b (bytes), k or kb (kilobytes), m or

701

Units can be specified as b (bytes), k or kb (kilobytes), m or

702

mb (megabytes), g or gb (gigabytes).

702

mb (megabytes), g or gb (gigabytes).

703

704

>>> u = ui(); s = b'foo'

704

>>> u = ui(); s = b'foo'

705

>>> u.setconfig(s, b'val1', b'42')

705

>>> u.setconfig(s, b'val1', b'42')

706

>>> u.configbytes(s, b'val1')

706

>>> u.configbytes(s, b'val1')

707

42

707

42

708

>>> u.setconfig(s, b'val2', b'42.5 kb')

708

>>> u.setconfig(s, b'val2', b'42.5 kb')

709

>>> u.configbytes(s, b'val2')

709

>>> u.configbytes(s, b'val2')

710

43520

710

43520

711

>>> u.configbytes(s, b'unknown', b'7 MB')

711

>>> u.configbytes(s, b'unknown', b'7 MB')

712

7340032

712

7340032

713

>>> u.setconfig(s, b'invalid', b'somevalue')

713

>>> u.setconfig(s, b'invalid', b'somevalue')

714

>>> u.configbytes(s, b'invalid')

714

>>> u.configbytes(s, b'invalid')

715

Traceback (most recent call last):

715

Traceback (most recent call last):

716

...

716

...

717

ConfigError: foo.invalid is not a byte quantity ('somevalue')

717

ConfigError: foo.invalid is not a byte quantity ('somevalue')

718

"""

718

"""

719

720

value = self._config(section, name, default, untrusted)

720

value = self._config(section, name, default, untrusted)

721

if value is _unset:

721

if value is _unset:

722

if default is _unset:

722

if default is _unset:

723

default = 0

723

default = 0

724

value = default

724

value = default

725

if not isinstance(value, bytes):

725

if not isinstance(value, bytes):

726

return value

726

return value

727

try:

727

try:

728

return util.sizetoint(value)

728

return util.sizetoint(value)

729

except error.ParseError:

729

except error.ParseError:

730

raise error.ConfigError(_("%s.%s is not a byte quantity ('%s')")

730

raise error.ConfigError(_("%s.%s is not a byte quantity ('%s')")

731

% (section, name, value))

731

% (section, name, value))

732

733

def configlist(self, section, name, default=_unset, untrusted=False):

733

def configlist(self, section, name, default=_unset, untrusted=False):

734

"""parse a configuration element as a list of comma/space separated

734

"""parse a configuration element as a list of comma/space separated

735

strings

735

strings

736

737

>>> u = ui(); s = b'foo'

737

>>> u = ui(); s = b'foo'

738

>>> u.setconfig(s, b'list1', b'this,is "a small" ,test')

738

>>> u.setconfig(s, b'list1', b'this,is "a small" ,test')

739

>>> u.configlist(s, b'list1')

739

>>> u.configlist(s, b'list1')

740

['this', 'is', 'a small', 'test']

740

['this', 'is', 'a small', 'test']

741

>>> u.setconfig(s, b'list2', b'this, is "a small" , test ')

741

>>> u.setconfig(s, b'list2', b'this, is "a small" , test ')

742

>>> u.configlist(s, b'list2')

742

>>> u.configlist(s, b'list2')

743

['this', 'is', 'a small', 'test']

743

['this', 'is', 'a small', 'test']

744

"""

744

"""

745

# default is not always a list

745

# default is not always a list

746

v = self.configwith(config.parselist, section, name, default,

746

v = self.configwith(config.parselist, section, name, default,

747

'list', untrusted)

747

'list', untrusted)

748

if isinstance(v, bytes):

748

if isinstance(v, bytes):

749

return config.parselist(v)

749

return config.parselist(v)

750

elif v is None:

750

elif v is None:

751

return []

751

return []

752

return v

752

return v

753

754

def configdate(self, section, name, default=_unset, untrusted=False):

754

def configdate(self, section, name, default=_unset, untrusted=False):

755

"""parse a configuration element as a tuple of ints

755

"""parse a configuration element as a tuple of ints

756

757

>>> u = ui(); s = b'foo'

757

>>> u = ui(); s = b'foo'

758

>>> u.setconfig(s, b'date', b'0 0')

758

>>> u.setconfig(s, b'date', b'0 0')

759

>>> u.configdate(s, b'date')

759

>>> u.configdate(s, b'date')

760

(0, 0)

760

(0, 0)

761

"""

761

"""

762

if self.config(section, name, default, untrusted):

762

if self.config(section, name, default, untrusted):

763

return self.configwith(dateutil.parsedate, section, name, default,

763

return self.configwith(dateutil.parsedate, section, name, default,

764

'date', untrusted)

764

'date', untrusted)

765

if default is _unset:

765

if default is _unset:

766

return None

766

return None

767

return default

767

return default

768

769

def hasconfig(self, section, name, untrusted=False):

769

def hasconfig(self, section, name, untrusted=False):

770

return self._data(untrusted).hasitem(section, name)

770

return self._data(untrusted).hasitem(section, name)

771

772

def has_section(self, section, untrusted=False):

772

def has_section(self, section, untrusted=False):

773

'''tell whether section exists in config.'''

773

'''tell whether section exists in config.'''

774

return section in self._data(untrusted)

774

return section in self._data(untrusted)

775

776

def configitems(self, section, untrusted=False, ignoresub=False):

776

def configitems(self, section, untrusted=False, ignoresub=False):

777

items = self._data(untrusted).items(section)

777

items = self._data(untrusted).items(section)

778

if ignoresub:

778

if ignoresub:

779

items = [i for i in items if ':' not in i[0]]

779

items = [i for i in items if ':' not in i[0]]

780

if self.debugflag and not untrusted and self._reportuntrusted:

780

if self.debugflag and not untrusted and self._reportuntrusted:

781

for k, v in self._ucfg.items(section):

781

for k, v in self._ucfg.items(section):

782

if self._tcfg.get(section, k) != v:

782

if self._tcfg.get(section, k) != v:

783

self.debug("ignoring untrusted configuration option "

783

self.debug("ignoring untrusted configuration option "

784

"%s.%s = %s\n" % (section, k, v))

784

"%s.%s = %s\n" % (section, k, v))

785

return items

785

return items

786

787

def walkconfig(self, untrusted=False):

787

def walkconfig(self, untrusted=False):

788

cfg = self._data(untrusted)

788

cfg = self._data(untrusted)

789

for section in cfg.sections():

789

for section in cfg.sections():

790

for name, value in self.configitems(section, untrusted):

790

for name, value in self.configitems(section, untrusted):

791

yield section, name, value

791

yield section, name, value

792

793

def plain(self, feature=None):

793

def plain(self, feature=None):

794

'''is plain mode active?

794

'''is plain mode active?

795

796

Plain mode means that all configuration variables which affect

796

Plain mode means that all configuration variables which affect

797

the behavior and output of Mercurial should be

797

the behavior and output of Mercurial should be

798

ignored. Additionally, the output should be stable,

798

ignored. Additionally, the output should be stable,

799

reproducible and suitable for use in scripts or applications.

799

reproducible and suitable for use in scripts or applications.

800

801

The only way to trigger plain mode is by setting either the

801

The only way to trigger plain mode is by setting either the

802

`HGPLAIN' or `HGPLAINEXCEPT' environment variables.

802

`HGPLAIN' or `HGPLAINEXCEPT' environment variables.

803

804

The return value can either be

804

The return value can either be

805

- False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT

805

- False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT

806

- False if feature is disabled by default and not included in HGPLAIN

806

- False if feature is disabled by default and not included in HGPLAIN

807

- True otherwise

807

- True otherwise

808

'''

808

'''

809

if ('HGPLAIN' not in encoding.environ and

809

if ('HGPLAIN' not in encoding.environ and

810

'HGPLAINEXCEPT' not in encoding.environ):

810

'HGPLAINEXCEPT' not in encoding.environ):

811

return False

811

return False

812

exceptions = encoding.environ.get('HGPLAINEXCEPT',

812

exceptions = encoding.environ.get('HGPLAINEXCEPT',

813

'').strip().split(',')

813

'').strip().split(',')

814

# TODO: add support for HGPLAIN=+feature,-feature syntax

814

# TODO: add support for HGPLAIN=+feature,-feature syntax

815

if '+strictflags' not in encoding.environ.get('HGPLAIN', '').split(','):

815

if '+strictflags' not in encoding.environ.get('HGPLAIN', '').split(','):

816

exceptions.append('strictflags')

816

exceptions.append('strictflags')

817

if feature and exceptions:

817

if feature and exceptions:

818

return feature not in exceptions

818

return feature not in exceptions

819

return True

819

return True

820

821

def username(self, acceptempty=False):

821

def username(self, acceptempty=False):

822

"""Return default username to be used in commits.

822

"""Return default username to be used in commits.

823

824

Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL

824

Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL

825

and stop searching if one of these is set.

825

and stop searching if one of these is set.

826

If not found and acceptempty is True, returns None.

826

If not found and acceptempty is True, returns None.

827

If not found and ui.askusername is True, ask the user, else use

827

If not found and ui.askusername is True, ask the user, else use

828

($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".

828

($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".

829

If no username could be found, raise an Abort error.

829

If no username could be found, raise an Abort error.

830

"""

830

"""

831

user = encoding.environ.get("HGUSER")

831

user = encoding.environ.get("HGUSER")

832

if user is None:

832

if user is None:

833

user = self.config("ui", "username")

833

user = self.config("ui", "username")

834

if user is not None:

834

if user is not None:

835

user = os.path.expandvars(user)

835

user = os.path.expandvars(user)

836

if user is None:

836

if user is None:

837

user = encoding.environ.get("EMAIL")

837

user = encoding.environ.get("EMAIL")

838

if user is None and acceptempty:

838

if user is None and acceptempty:

839

return user

839

return user

840

if user is None and self.configbool("ui", "askusername"):

840

if user is None and self.configbool("ui", "askusername"):

841

user = self.prompt(_("enter a commit username:"), default=None)

841

user = self.prompt(_("enter a commit username:"), default=None)

842

if user is None and not self.interactive():

842

if user is None and not self.interactive():

843

try:

843

try:

844

user = '%s@%s' % (procutil.getuser(),

844

user = '%s@%s' % (procutil.getuser(),

845

encoding.strtolocal(socket.getfqdn()))

845

encoding.strtolocal(socket.getfqdn()))

846

self.warn(_("no username found, using '%s' instead\n") % user)

846

self.warn(_("no username found, using '%s' instead\n") % user)

847

except KeyError:

847

except KeyError:

848

pass

848

pass

849

if not user:

849

if not user:

850

raise error.Abort(_('no username supplied'),

850

raise error.Abort(_('no username supplied'),

851

hint=_("use 'hg config --edit' "

851

hint=_("use 'hg config --edit' "

852

'to set your username'))

852

'to set your username'))

853

if "\n" in user:

853

if "\n" in user:

854

raise error.Abort(_("username %r contains a newline\n")

854

raise error.Abort(_("username %r contains a newline\n")

855

% pycompat.bytestr(user))

855

% pycompat.bytestr(user))

856

return user

856

return user

857

858

def shortuser(self, user):

858

def shortuser(self, user):

859

"""Return a short representation of a user name or email address."""

859

"""Return a short representation of a user name or email address."""

860

if not self.verbose:

860

if not self.verbose:

861

user = stringutil.shortuser(user)

861

user = stringutil.shortuser(user)

862

return user

862

return user

863

864

def expandpath(self, loc, default=None):

864

def expandpath(self, loc, default=None):

865

"""Return repository location relative to cwd or from [paths]"""

865

"""Return repository location relative to cwd or from [paths]"""

866

try:

866

try:

867

p = self.paths.getpath(loc)

867

p = self.paths.getpath(loc)

868

if p:

868

if p:

869

return p.rawloc

869

return p.rawloc

870

except error.RepoError:

870

except error.RepoError:

871

pass

871

pass

872

873

if default:

873

if default:

874

try:

874

try:

875

p = self.paths.getpath(default)

875

p = self.paths.getpath(default)

876

if p:

876

if p:

877

return p.rawloc

877

return p.rawloc

878

except error.RepoError:

878

except error.RepoError:

879

pass

879

pass

880

881

return loc

881

return loc

882

883

@util.propertycache

883

@util.propertycache

884

def paths(self):

884

def paths(self):

885

return paths(self)

885

return paths(self)

886

887

def pushbuffer(self, error=False, subproc=False, labeled=False):

887

def pushbuffer(self, error=False, subproc=False, labeled=False):

888

"""install a buffer to capture standard output of the ui object

888

"""install a buffer to capture standard output of the ui object

889

890

If error is True, the error output will be captured too.

890

If error is True, the error output will be captured too.

891

892

If subproc is True, output from subprocesses (typically hooks) will be

892

If subproc is True, output from subprocesses (typically hooks) will be

893

captured too.

893

captured too.

894

895

If labeled is True, any labels associated with buffered

895

If labeled is True, any labels associated with buffered

896

output will be handled. By default, this has no effect

896

output will be handled. By default, this has no effect

897

on the output returned, but extensions and GUI tools may

897

on the output returned, but extensions and GUI tools may

898

handle this argument and returned styled output. If output

898

handle this argument and returned styled output. If output

899

is being buffered so it can be captured and parsed or

899

is being buffered so it can be captured and parsed or

900

processed, labeled should not be set to True.

900

processed, labeled should not be set to True.

901

"""

901

"""

902

self._buffers.append([])

902

self._buffers.append([])

903

self._bufferstates.append((error, subproc, labeled))

903

self._bufferstates.append((error, subproc, labeled))

904

self._bufferapplylabels = labeled

904

self._bufferapplylabels = labeled

905

906

def popbuffer(self):

906

def popbuffer(self):

907

'''pop the last buffer and return the buffered output'''

907

'''pop the last buffer and return the buffered output'''

908

self._bufferstates.pop()

908

self._bufferstates.pop()

909

if self._bufferstates:

909

if self._bufferstates:

910

self._bufferapplylabels = self._bufferstates[-1][2]

910

self._bufferapplylabels = self._bufferstates[-1][2]

911

else:

911

else:

912

self._bufferapplylabels = None

912

self._bufferapplylabels = None

913

914

return "".join(self._buffers.pop())

914

return "".join(self._buffers.pop())

915

916

def canwritewithoutlabels(self):

916

def canwritewithoutlabels(self):

917

'''check if write skips the label'''

917

'''check if write skips the label'''

918

if self._buffers and not self._bufferapplylabels:

918

if self._buffers and not self._bufferapplylabels:

919

return True

919

return True

920

return self._colormode is None

920

return self._colormode is None

921

922

def canbatchlabeledwrites(self):

922

def canbatchlabeledwrites(self):

923

'''check if write calls with labels are batchable'''

923

'''check if write calls with labels are batchable'''

924

# Windows color printing is special, see ``write``.

924

# Windows color printing is special, see ``write``.

925

return self._colormode != 'win32'

925

return self._colormode != 'win32'

926

927

def write(self, *args, **opts):

927

def write(self, *args, **opts):

928

'''write args to output

928

'''write args to output

929

930

By default, this method simply writes to the buffer or stdout.

930

By default, this method simply writes to the buffer or stdout.

931

Color mode can be set on the UI class to have the output decorated

931

Color mode can be set on the UI class to have the output decorated

932

with color modifier before being written to stdout.

932

with color modifier before being written to stdout.

933

934

The color used is controlled by an optional keyword argument, "label".

934

The color used is controlled by an optional keyword argument, "label".

935

This should be a string containing label names separated by space.

935

This should be a string containing label names separated by space.

936

Label names take the form of "topic.type". For example, ui.debug()

936

Label names take the form of "topic.type". For example, ui.debug()

937

issues a label of "ui.debug".

937

issues a label of "ui.debug".

938

939

When labeling output for a specific command, a label of

939

When labeling output for a specific command, a label of

940

"cmdname.type" is recommended. For example, status issues

940

"cmdname.type" is recommended. For example, status issues

941

a label of "status.modified" for modified files.

941

a label of "status.modified" for modified files.

942

'''

942

'''

943

if self._buffers:

943

if self._buffers:

944

if self._bufferapplylabels:

944

if self._bufferapplylabels:

945

label = opts.get(r'label', '')

945

label = opts.get(r'label', '')

946

self._buffers[-1].extend(self.label(a, label) for a in args)

946

self._buffers[-1].extend(self.label(a, label) for a in args)

947

else:

947

else:

948

self._buffers[-1].extend(args)

948

self._buffers[-1].extend(args)

949

else:

949

else:

950

self._writenobuf(*args, **opts)

950

self._writenobuf(*args, **opts)

951

952

def _writenobuf(self, *args, **opts):

952

def _writenobuf(self, *args, **opts):

953

if self._colormode == 'win32':

953

if self._colormode == 'win32':

954

# windows color printing is its own can of crab, defer to

954

# windows color printing is its own can of crab, defer to

955

# the color module and that is it.

955

# the color module and that is it.

956

color.win32print(self, self._write, *args, **opts)

956

color.win32print(self, self._write, *args, **opts)

957

else:

957

else:

958

msgs = args

958

msgs = args

959

if self._colormode is not None:

959

if self._colormode is not None:

960

label = opts.get(r'label', '')

960

label = opts.get(r'label', '')

961

msgs = [self.label(a, label) for a in args]

961

msgs = [self.label(a, label) for a in args]

962

self._write(*msgs, **opts)

962

self._write(*msgs, **opts)

963

964

def _write(self, *msgs, **opts):

964

def _write(self, *msgs, **opts):

965

self._progclear()

965

self._progclear()

966

# opencode timeblockedsection because this is a critical path

966

# opencode timeblockedsection because this is a critical path

967

starttime = util.timer()

967

starttime = util.timer()

968

try:

968

try:

969

self.fout.write(''.join(msgs))

969

self.fout.write(''.join(msgs))

970

except IOError as err:

970

except IOError as err:

971

raise error.StdioError(err)

971

raise error.StdioError(err)

972

finally:

972

finally:

973

self._blockedtimes['stdio_blocked'] += \

973

self._blockedtimes['stdio_blocked'] += \

974

(util.timer() - starttime) * 1000

974

(util.timer() - starttime) * 1000

975

976

def write_err(self, *args, **opts):

976

def write_err(self, *args, **opts):

977

self._progclear()

977

self._progclear()

978

if self._bufferstates and self._bufferstates[-1][0]:

978

if self._bufferstates and self._bufferstates[-1][0]:

979

self.write(*args, **opts)

979

self.write(*args, **opts)

980

elif self._colormode == 'win32':

980

elif self._colormode == 'win32':

981

# windows color printing is its own can of crab, defer to

981

# windows color printing is its own can of crab, defer to

982

# the color module and that is it.

982

# the color module and that is it.

983

color.win32print(self, self._write_err, *args, **opts)

983

color.win32print(self, self._write_err, *args, **opts)

984

else:

984

else:

985

msgs = args

985

msgs = args

986

if self._colormode is not None:

986

if self._colormode is not None:

987

label = opts.get(r'label', '')

987

label = opts.get(r'label', '')

988

msgs = [self.label(a, label) for a in args]

988

msgs = [self.label(a, label) for a in args]

989

self._write_err(*msgs, **opts)

989

self._write_err(*msgs, **opts)

990

991

def _write_err(self, *msgs, **opts):

991

def _write_err(self, *msgs, **opts):

992

try:

992

try:

993

with self.timeblockedsection('stdio'):

993

with self.timeblockedsection('stdio'):

994

if not getattr(self.fout, 'closed', False):

994

if not getattr(self.fout, 'closed', False):

995

self.fout.flush()

995

self.fout.flush()

996

for a in msgs:

996

for a in msgs:

997

self.ferr.write(a)

997

self.ferr.write(a)

998

# stderr may be buffered under win32 when redirected to files,

998

# stderr may be buffered under win32 when redirected to files,

999

# including stdout.

999

# including stdout.

1000

if not getattr(self.ferr, 'closed', False):

1000

if not getattr(self.ferr, 'closed', False):

1001

self.ferr.flush()

1001

self.ferr.flush()

1002

except IOError as inst:

1002

except IOError as inst:

1003

if inst.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):

1003

if inst.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):

1004

raise error.StdioError(inst)

1004

raise error.StdioError(inst)

1005

1006

def flush(self):

1006

def flush(self):

1007

# opencode timeblockedsection because this is a critical path

1007

# opencode timeblockedsection because this is a critical path

1008

starttime = util.timer()

1008

starttime = util.timer()

1009

try:

1009

try:

1010

try:

1010

try:

1011

self.fout.flush()

1011

self.fout.flush()

1012

except IOError as err:

1012

except IOError as err:

1013

if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):

1013

if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):

1014

raise error.StdioError(err)

1014

raise error.StdioError(err)

1015

finally:

1015

finally:

1016

try:

1016

try:

1017

self.ferr.flush()

1017

self.ferr.flush()

1018

except IOError as err:

1018

except IOError as err:

1019

if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):

1019

if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):

1020

raise error.StdioError(err)

1020

raise error.StdioError(err)

1021

finally:

1021

finally:

1022

self._blockedtimes['stdio_blocked'] += \

1022

self._blockedtimes['stdio_blocked'] += \

1023

(util.timer() - starttime) * 1000

1023

(util.timer() - starttime) * 1000

1024

1025

def _isatty(self, fh):

1025

def _isatty(self, fh):

1026

if self.configbool('ui', 'nontty'):

1026

if self.configbool('ui', 'nontty'):

1027

return False

1027

return False

1028

return procutil.isatty(fh)

1028

return procutil.isatty(fh)

1029

1030

def disablepager(self):

1030

def disablepager(self):

1031

self._disablepager = True

1031

self._disablepager = True

1032

1033

def pager(self, command):

1033

def pager(self, command):

1034

"""Start a pager for subsequent command output.

1034

"""Start a pager for subsequent command output.

1035

1036

Commands which produce a long stream of output should call

1036

Commands which produce a long stream of output should call

1037

this function to activate the user's preferred pagination

1037

this function to activate the user's preferred pagination

1038

mechanism (which may be no pager). Calling this function

1038

mechanism (which may be no pager). Calling this function

1039

precludes any future use of interactive functionality, such as

1039

precludes any future use of interactive functionality, such as

1040

prompting the user or activating curses.

1040

prompting the user or activating curses.

1041

1042

Args:

1042

Args:

1043

command: The full, non-aliased name of the command. That is, "log"

1043

command: The full, non-aliased name of the command. That is, "log"

1044

not "history, "summary" not "summ", etc.

1044

not "history, "summary" not "summ", etc.

1045

"""

1045

"""

1046

if (self._disablepager

1046

if (self._disablepager

1047

or self.pageractive):

1047

or self.pageractive):

1048

# how pager should do is already determined

1048

# how pager should do is already determined

1049

return

1049

return

1050

1051

if not command.startswith('internal-always-') and (

1051

if not command.startswith('internal-always-') and (

1052

# explicit --pager=on (= 'internal-always-' prefix) should

1052

# explicit --pager=on (= 'internal-always-' prefix) should

1053

# take precedence over disabling factors below

1053

# take precedence over disabling factors below

1054

command in self.configlist('pager', 'ignore')

1054

command in self.configlist('pager', 'ignore')

1055

or not self.configbool('ui', 'paginate')

1055

or not self.configbool('ui', 'paginate')

1056

or not self.configbool('pager', 'attend-' + command, True)

1056

or not self.configbool('pager', 'attend-' + command, True)

1057

or encoding.environ.get('TERM') == 'dumb'

1057

or encoding.environ.get('TERM') == 'dumb'

1058

# TODO: if we want to allow HGPLAINEXCEPT=pager,

1058

# TODO: if we want to allow HGPLAINEXCEPT=pager,

1059

# formatted() will need some adjustment.

1059

# formatted() will need some adjustment.

1060

or not self.formatted()

1060

or not self.formatted()

1061

or self.plain()

1061

or self.plain()

1062

or self._buffers

1062

or self._buffers

1063

# TODO: expose debugger-enabled on the UI object

1063

# TODO: expose debugger-enabled on the UI object

1064

or '--debugger' in pycompat.sysargv):

1064

or '--debugger' in pycompat.sysargv):

1065

# We only want to paginate if the ui appears to be

1065

# We only want to paginate if the ui appears to be

1066

# interactive, the user didn't say HGPLAIN or

1066

# interactive, the user didn't say HGPLAIN or

1067

# HGPLAINEXCEPT=pager, and the user didn't specify --debug.

1067

# HGPLAINEXCEPT=pager, and the user didn't specify --debug.

1068

return

1068

return

1069

1070

pagercmd = self.config('pager', 'pager', rcutil.fallbackpager)

1070

pagercmd = self.config('pager', 'pager', rcutil.fallbackpager)

1071

if not pagercmd:

1071

if not pagercmd:

1072

return

1072

return

1073

1074

pagerenv = {}

1074

pagerenv = {}

1075

for name, value in rcutil.defaultpagerenv().items():

1075

for name, value in rcutil.defaultpagerenv().items():

1076

if name not in encoding.environ:

1076

if name not in encoding.environ:

1077

pagerenv[name] = value

1077

pagerenv[name] = value

1078

1079

self.debug('starting pager for command %r\n' % ~~command~~)

1079

self.debug('starting pager for command %s\n' %

1080

stringutil.pprint(command))

1080

self.flush()

1081

self.flush()

1081

1082

wasformatted = self.formatted()

1083

wasformatted = self.formatted()

1083

if util.safehasattr(signal, "SIGPIPE"):

1084

if util.safehasattr(signal, "SIGPIPE"):

1084

signal.signal(signal.SIGPIPE, _catchterm)

1085

signal.signal(signal.SIGPIPE, _catchterm)

1085

if self._runpager(pagercmd, pagerenv):

1086

if self._runpager(pagercmd, pagerenv):

1086

self.pageractive = True

1087

self.pageractive = True

1087

# Preserve the formatted-ness of the UI. This is important

1088

# Preserve the formatted-ness of the UI. This is important

1088

# because we mess with stdout, which might confuse

1089

# because we mess with stdout, which might confuse

1089

# auto-detection of things being formatted.

1090

# auto-detection of things being formatted.

1090

self.setconfig('ui', 'formatted', wasformatted, 'pager')

1091

self.setconfig('ui', 'formatted', wasformatted, 'pager')

1091

self.setconfig('ui', 'interactive', False, 'pager')

1092

self.setconfig('ui', 'interactive', False, 'pager')

1092

1093

# If pagermode differs from color.mode, reconfigure color now that

1094

# If pagermode differs from color.mode, reconfigure color now that

1094

# pageractive is set.

1095

# pageractive is set.

1095

cm = self._colormode

1096

cm = self._colormode

1096

if cm != self.config('color', 'pagermode', cm):

1097

if cm != self.config('color', 'pagermode', cm):

1097

color.setup(self)

1098

color.setup(self)

1098

else:

1099

else:

1099

# If the pager can't be spawned in dispatch when --pager=on is

1100

# If the pager can't be spawned in dispatch when --pager=on is

1100

# given, don't try again when the command runs, to avoid a duplicate

1101

# given, don't try again when the command runs, to avoid a duplicate

1101

# warning about a missing pager command.

1102

# warning about a missing pager command.

1102

self.disablepager()

1103

self.disablepager()

1103

1104

def _runpager(self, command, env=None):

1105

def _runpager(self, command, env=None):

1105

"""Actually start the pager and set up file descriptors.

1106

"""Actually start the pager and set up file descriptors.

1106

1107

This is separate in part so that extensions (like chg) can

1108

This is separate in part so that extensions (like chg) can

1108

override how a pager is invoked.

1109

override how a pager is invoked.

1109

"""

1110

"""

1110

if command == 'cat':

1111

if command == 'cat':

1111

# Save ourselves some work.

1112

# Save ourselves some work.

1112

return False

1113

return False

1113

# If the command doesn't contain any of these characters, we

1114

# If the command doesn't contain any of these characters, we

1114

# assume it's a binary and exec it directly. This means for

1115

# assume it's a binary and exec it directly. This means for

1115

# simple pager command configurations, we can degrade

1116

# simple pager command configurations, we can degrade

1116

# gracefully and tell the user about their broken pager.

1117

# gracefully and tell the user about their broken pager.

1117

shell = any(c in command for c in "|&;<>()$`\\\"' \t\n*?[#~=%")

1118

shell = any(c in command for c in "|&;<>()$`\\\"' \t\n*?[#~=%")

1118

1119

if pycompat.iswindows and not shell:

1120

if pycompat.iswindows and not shell:

1120

# Window's built-in `more` cannot be invoked with shell=False, but

1121

# Window's built-in `more` cannot be invoked with shell=False, but

1121

# its `more.com` can. Hide this implementation detail from the

1122

# its `more.com` can. Hide this implementation detail from the

1122

# user so we can also get sane bad PAGER behavior. MSYS has

1123

# user so we can also get sane bad PAGER behavior. MSYS has

1123

# `more.exe`, so do a cmd.exe style resolution of the executable to

1124

# `more.exe`, so do a cmd.exe style resolution of the executable to

1124

# determine which one to use.

1125

# determine which one to use.

1125

fullcmd = procutil.findexe(command)

1126

fullcmd = procutil.findexe(command)

1126

if not fullcmd:

1127

if not fullcmd:

1127

self.warn(_("missing pager command '%s', skipping pager\n")

1128

self.warn(_("missing pager command '%s', skipping pager\n")

1128

% command)

1129

% command)

1129

return False

1130

return False

1130

1131

command = fullcmd

1132

command = fullcmd

1132

1133

try:

1134

try:

1134

pager = subprocess.Popen(

1135

pager = subprocess.Popen(

1135

procutil.tonativestr(command), shell=shell, bufsize=-1,

1136

procutil.tonativestr(command), shell=shell, bufsize=-1,

1136

close_fds=procutil.closefds, stdin=subprocess.PIPE,

1137

close_fds=procutil.closefds, stdin=subprocess.PIPE,

1137

stdout=procutil.stdout, stderr=procutil.stderr,

1138

stdout=procutil.stdout, stderr=procutil.stderr,

1138

env=procutil.tonativeenv(procutil.shellenviron(env)))

1139

env=procutil.tonativeenv(procutil.shellenviron(env)))

1139

except OSError as e:

1140

except OSError as e:

1140

if e.errno == errno.ENOENT and not shell:

1141

if e.errno == errno.ENOENT and not shell:

1141

self.warn(_("missing pager command '%s', skipping pager\n")

1142

self.warn(_("missing pager command '%s', skipping pager\n")

1142

% command)

1143

% command)

1143

return False

1144

return False

1144

raise

1145

raise

1145

1146

# back up original file descriptors

1147

# back up original file descriptors

1147

stdoutfd = os.dup(procutil.stdout.fileno())

1148

stdoutfd = os.dup(procutil.stdout.fileno())

1148

stderrfd = os.dup(procutil.stderr.fileno())

1149

stderrfd = os.dup(procutil.stderr.fileno())

1149

1150

os.dup2(pager.stdin.fileno(), procutil.stdout.fileno())

1151

os.dup2(pager.stdin.fileno(), procutil.stdout.fileno())

1151

if self._isatty(procutil.stderr):

1152

if self._isatty(procutil.stderr):

1152

os.dup2(pager.stdin.fileno(), procutil.stderr.fileno())

1153

os.dup2(pager.stdin.fileno(), procutil.stderr.fileno())

1153

1154

@self.atexit

1155

@self.atexit

1155

def killpager():

1156

def killpager():

1156

if util.safehasattr(signal, "SIGINT"):

1157

if util.safehasattr(signal, "SIGINT"):

1157

signal.signal(signal.SIGINT, signal.SIG_IGN)

1158

signal.signal(signal.SIGINT, signal.SIG_IGN)

1158

# restore original fds, closing pager.stdin copies in the process

1159

# restore original fds, closing pager.stdin copies in the process

1159

os.dup2(stdoutfd, procutil.stdout.fileno())

1160

os.dup2(stdoutfd, procutil.stdout.fileno())

1160

os.dup2(stderrfd, procutil.stderr.fileno())

1161

os.dup2(stderrfd, procutil.stderr.fileno())

1161

pager.stdin.close()

1162

pager.stdin.close()

1162

pager.wait()

1163

pager.wait()

1163

1164

return True

1165

return True

1165

1166

@property

1167

@property

1167

def _exithandlers(self):

1168

def _exithandlers(self):

1168

return _reqexithandlers

1169

return _reqexithandlers

1169

1170

def atexit(self, func, *args, **kwargs):

1171

def atexit(self, func, *args, **kwargs):

1171

'''register a function to run after dispatching a request

1172

'''register a function to run after dispatching a request

1172

1173

Handlers do not stay registered across request boundaries.'''

1174

Handlers do not stay registered across request boundaries.'''

1174

self._exithandlers.append((func, args, kwargs))

1175

self._exithandlers.append((func, args, kwargs))

1175

return func

1176

return func

1176

1177

def interface(self, feature):

1178

def interface(self, feature):

1178

"""what interface to use for interactive console features?

1179

"""what interface to use for interactive console features?

1179

1180

The interface is controlled by the value of `ui.interface` but also by

1181

The interface is controlled by the value of `ui.interface` but also by

1181

the value of feature-specific configuration. For example:

1182

the value of feature-specific configuration. For example:

1182

1183

ui.interface.histedit = text

1184

ui.interface.histedit = text

1184

ui.interface.chunkselector = curses

1185

ui.interface.chunkselector = curses

1185

1186

Here the features are "histedit" and "chunkselector".

1187

Here the features are "histedit" and "chunkselector".

1187

1188

The configuration above means that the default interfaces for commands

1189

The configuration above means that the default interfaces for commands

1189

is curses, the interface for histedit is text and the interface for

1190

is curses, the interface for histedit is text and the interface for

1190

selecting chunk is crecord (the best curses interface available).

1191

selecting chunk is crecord (the best curses interface available).

1191

1192

Consider the following example:

1193

Consider the following example:

1193

ui.interface = curses

1194

ui.interface = curses

1194

ui.interface.histedit = text

1195

ui.interface.histedit = text

1195

1196

Then histedit will use the text interface and chunkselector will use

1197

Then histedit will use the text interface and chunkselector will use

1197

the default curses interface (crecord at the moment).

1198

the default curses interface (crecord at the moment).

1198

"""

1199

"""

1199

alldefaults = frozenset(["text", "curses"])

1200

alldefaults = frozenset(["text", "curses"])

1200

1201

featureinterfaces = {

1202

featureinterfaces = {

1202

"chunkselector": [

1203

"chunkselector": [

1203

"text",

1204

"text",

1204

"curses",

1205

"curses",

1205

]

1206

]

1206

}

1207

}

1207

1208

# Feature-specific interface

1209

# Feature-specific interface

1209

if feature not in featureinterfaces.keys():

1210

if feature not in featureinterfaces.keys():

1210

# Programming error, not user error

1211

# Programming error, not user error

1211

raise ValueError("Unknown feature requested %s" % feature)

1212

raise ValueError("Unknown feature requested %s" % feature)

1212

1213

availableinterfaces = frozenset(featureinterfaces[feature])

1214

availableinterfaces = frozenset(featureinterfaces[feature])

1214

if alldefaults > availableinterfaces:

1215

if alldefaults > availableinterfaces:

1215

# Programming error, not user error. We need a use case to

1216

# Programming error, not user error. We need a use case to

1216

# define the right thing to do here.

1217

# define the right thing to do here.

1217

raise ValueError(

1218

raise ValueError(

1218

"Feature %s does not handle all default interfaces" %

1219

"Feature %s does not handle all default interfaces" %

1219

feature)

1220

feature)

1220

1221

if self.plain() or encoding.environ.get('TERM') == 'dumb':

1222

if self.plain() or encoding.environ.get('TERM') == 'dumb':

1222

return "text"

1223

return "text"

1223

1224

# Default interface for all the features

1225

# Default interface for all the features

1225

defaultinterface = "text"

1226

defaultinterface = "text"

1226

i = self.config("ui", "interface")

1227

i = self.config("ui", "interface")

1227

if i in alldefaults:

1228

if i in alldefaults:

1228

defaultinterface = i

1229

defaultinterface = i

1229

1230

choseninterface = defaultinterface

1231

choseninterface = defaultinterface

1231

f = self.config("ui", "interface.%s" % feature)

1232

f = self.config("ui", "interface.%s" % feature)

1232

if f in availableinterfaces:

1233

if f in availableinterfaces:

1233

choseninterface = f

1234

choseninterface = f

1234

1235

if i is not None and defaultinterface != i:

1236

if i is not None and defaultinterface != i:

1236

if f is not None:

1237

if f is not None:

1237

self.warn(_("invalid value for ui.interface: %s\n") %

1238

self.warn(_("invalid value for ui.interface: %s\n") %

1238

(i,))

1239

(i,))

1239

else:

1240

else:

1240

self.warn(_("invalid value for ui.interface: %s (using %s)\n") %

1241

self.warn(_("invalid value for ui.interface: %s (using %s)\n") %

1241

(i, choseninterface))

1242

(i, choseninterface))

1242

if f is not None and choseninterface != f:

1243

if f is not None and choseninterface != f:

1243

self.warn(_("invalid value for ui.interface.%s: %s (using %s)\n") %

1244

self.warn(_("invalid value for ui.interface.%s: %s (using %s)\n") %

1244

(feature, f, choseninterface))

1245

(feature, f, choseninterface))

1245

1246

return choseninterface

1247

return choseninterface

1247

1248

def interactive(self):

1249

def interactive(self):

1249

'''is interactive input allowed?

1250

'''is interactive input allowed?

1250

1251

An interactive session is a session where input can be reasonably read

1252

An interactive session is a session where input can be reasonably read

1252

from `sys.stdin'. If this function returns false, any attempt to read

1253

from `sys.stdin'. If this function returns false, any attempt to read

1253

from stdin should fail with an error, unless a sensible default has been

1254

from stdin should fail with an error, unless a sensible default has been

1254

specified.

1255

specified.

1255

1256

Interactiveness is triggered by the value of the `ui.interactive'

1257

Interactiveness is triggered by the value of the `ui.interactive'

1257

configuration variable or - if it is unset - when `sys.stdin' points

1258

configuration variable or - if it is unset - when `sys.stdin' points

1258

to a terminal device.

1259

to a terminal device.

1259

1260

This function refers to input only; for output, see `ui.formatted()'.

1261

This function refers to input only; for output, see `ui.formatted()'.

1261

'''

1262

'''

1262

i = self.configbool("ui", "interactive")

1263

i = self.configbool("ui", "interactive")

1263

if i is None:

1264

if i is None:

1264

# some environments replace stdin without implementing isatty

1265

# some environments replace stdin without implementing isatty

1265

# usually those are non-interactive

1266

# usually those are non-interactive

1266

return self._isatty(self.fin)

1267

return self._isatty(self.fin)

1267

1268

return i

1269

return i

1269

1270

def termwidth(self):

1271

def termwidth(self):

1271

'''how wide is the terminal in columns?

1272

'''how wide is the terminal in columns?

1272

'''

1273

'''

1273

if 'COLUMNS' in encoding.environ:

1274

if 'COLUMNS' in encoding.environ:

1274

try:

1275

try:

1275

return int(encoding.environ['COLUMNS'])

1276

return int(encoding.environ['COLUMNS'])

1276

except ValueError:

1277

except ValueError:

1277

pass

1278

pass

1278

return scmutil.termsize(self)[0]

1279

return scmutil.termsize(self)[0]

1279

1280

def formatted(self):

1281

def formatted(self):

1281

'''should formatted output be used?

1282

'''should formatted output be used?

1282

1283

It is often desirable to format the output to suite the output medium.

1284

It is often desirable to format the output to suite the output medium.

1284

Examples of this are truncating long lines or colorizing messages.

1285

Examples of this are truncating long lines or colorizing messages.

1285

However, this is not often not desirable when piping output into other

1286

However, this is not often not desirable when piping output into other

1286

utilities, e.g. `grep'.

1287

utilities, e.g. `grep'.

1287

1288

Formatted output is triggered by the value of the `ui.formatted'

1289

Formatted output is triggered by the value of the `ui.formatted'

1289

configuration variable or - if it is unset - when `sys.stdout' points

1290

configuration variable or - if it is unset - when `sys.stdout' points

1290

to a terminal device. Please note that `ui.formatted' should be

1291

to a terminal device. Please note that `ui.formatted' should be

1291

considered an implementation detail; it is not intended for use outside

1292

considered an implementation detail; it is not intended for use outside

1292

Mercurial or its extensions.

1293

Mercurial or its extensions.

1293

1294

This function refers to output only; for input, see `ui.interactive()'.

1295

This function refers to output only; for input, see `ui.interactive()'.

1295

This function always returns false when in plain mode, see `ui.plain()'.

1296

This function always returns false when in plain mode, see `ui.plain()'.

1296

'''

1297

'''

1297

if self.plain():

1298

if self.plain():

1298

return False

1299

return False

1299

1300

i = self.configbool("ui", "formatted")

1301

i = self.configbool("ui", "formatted")

1301

if i is None:

1302

if i is None:

1302

# some environments replace stdout without implementing isatty

1303

# some environments replace stdout without implementing isatty

1303

# usually those are non-interactive

1304

# usually those are non-interactive

1304

return self._isatty(self.fout)

1305

return self._isatty(self.fout)

1305

1306

return i

1307

return i

1307

1308

def _readline(self):

1309

def _readline(self):

1309

# Replacing stdin/stdout temporarily is a hard problem on Python 3

1310

# Replacing stdin/stdout temporarily is a hard problem on Python 3

1310

# because they have to be text streams with *no buffering*. Instead,

1311

# because they have to be text streams with *no buffering*. Instead,

1311

# we use rawinput() only if call_readline() will be invoked by

1312

# we use rawinput() only if call_readline() will be invoked by

1312

# PyOS_Readline(), so no I/O will be made at Python layer.

1313

# PyOS_Readline(), so no I/O will be made at Python layer.

1313

usereadline = (self._isatty(self.fin) and self._isatty(self.fout)

1314

usereadline = (self._isatty(self.fin) and self._isatty(self.fout)

1314

and procutil.isstdin(self.fin)

1315

and procutil.isstdin(self.fin)

1315

and procutil.isstdout(self.fout))

1316

and procutil.isstdout(self.fout))

1316

if usereadline:

1317

if usereadline:

1317

try:

1318

try:

1318

# magically add command line editing support, where

1319

# magically add command line editing support, where

1319

# available

1320

# available

1320

import readline

1321

import readline

1321

# force demandimport to really load the module

1322

# force demandimport to really load the module

1322

readline.read_history_file

1323

readline.read_history_file

1323

# windows sometimes raises something other than ImportError

1324

# windows sometimes raises something other than ImportError

1324

except Exception:

1325

except Exception:

1325

usereadline = False

1326

usereadline = False

1326

1327

# prompt ' ' must exist; otherwise readline may delete entire line

1328

# prompt ' ' must exist; otherwise readline may delete entire line

1328

# - http://bugs.python.org/issue12833

1329

# - http://bugs.python.org/issue12833

1329

with self.timeblockedsection('stdio'):

1330

with self.timeblockedsection('stdio'):

1330

if usereadline:

1331

if usereadline:

1331

line = encoding.strtolocal(pycompat.rawinput(r' '))

1332

line = encoding.strtolocal(pycompat.rawinput(r' '))

1332

# When stdin is in binary mode on Windows, it can cause

1333

# When stdin is in binary mode on Windows, it can cause

1333

# raw_input() to emit an extra trailing carriage return

1334

# raw_input() to emit an extra trailing carriage return

1334

if pycompat.oslinesep == b'\r\n' and line.endswith(b'\r'):

1335

if pycompat.oslinesep == b'\r\n' and line.endswith(b'\r'):

1335

line = line[:-1]

1336

line = line[:-1]

1336

else:

1337

else:

1337

self.fout.write(b' ')

1338

self.fout.write(b' ')

1338

self.fout.flush()

1339

self.fout.flush()

1339

line = self.fin.readline()

1340

line = self.fin.readline()

1340

if not line:

1341

if not line:

1341

raise EOFError

1342

raise EOFError

1342

line = line.rstrip(pycompat.oslinesep)

1343

line = line.rstrip(pycompat.oslinesep)

1343

1344

return line

1345

return line

1345

1346

def prompt(self, msg, default="y"):

1347

def prompt(self, msg, default="y"):

1347

"""Prompt user with msg, read response.

1348

"""Prompt user with msg, read response.

1348

If ui is not interactive, the default is returned.

1349

If ui is not interactive, the default is returned.

1349

"""

1350

"""

1350

if not self.interactive():

1351

if not self.interactive():

1351

self.write(msg, ' ', default or '', "\n")

1352

self.write(msg, ' ', default or '', "\n")

1352

return default

1353

return default

1353

self._writenobuf(msg, label='ui.prompt')

1354

self._writenobuf(msg, label='ui.prompt')

1354

self.flush()

1355

self.flush()

1355

try:

1356

try:

1356

r = self._readline()

1357

r = self._readline()

1357

if not r:

1358

if not r:

1358

r = default

1359

r = default

1359

if self.configbool('ui', 'promptecho'):

1360

if self.configbool('ui', 'promptecho'):

1360

self.write(r, "\n")

1361

self.write(r, "\n")

1361

return r

1362

return r

1362

except EOFError:

1363

except EOFError:

1363

raise error.ResponseExpected()

1364

raise error.ResponseExpected()

1364

1365

@staticmethod

1366

@staticmethod

1366

def extractchoices(prompt):

1367

def extractchoices(prompt):

1367

"""Extract prompt message and list of choices from specified prompt.

1368

"""Extract prompt message and list of choices from specified prompt.

1368

1369

This returns tuple "(message, choices)", and "choices" is the

1370

This returns tuple "(message, choices)", and "choices" is the

1370

list of tuple "(response character, text without &)".

1371

list of tuple "(response character, text without &)".

1371

1372

>>> ui.extractchoices(b"awake? $$ &Yes $$ &No")

1373

>>> ui.extractchoices(b"awake? $$ &Yes $$ &No")

1373

('awake? ', [('y', 'Yes'), ('n', 'No')])

1374

('awake? ', [('y', 'Yes'), ('n', 'No')])

1374

>>> ui.extractchoices(b"line\\nbreak? $$ &Yes $$ &No")

1375

>>> ui.extractchoices(b"line\\nbreak? $$ &Yes $$ &No")

1375

('line\\nbreak? ', [('y', 'Yes'), ('n', 'No')])

1376

('line\\nbreak? ', [('y', 'Yes'), ('n', 'No')])

1376

>>> ui.extractchoices(b"want lots of $$money$$?$$Ye&s$$N&o")

1377

>>> ui.extractchoices(b"want lots of $$money$$?$$Ye&s$$N&o")

1377

('want lots of $$money$$?', [('s', 'Yes'), ('o', 'No')])

1378

('want lots of $$money$$?', [('s', 'Yes'), ('o', 'No')])

1378

"""

1379

"""

1379

1380

# Sadly, the prompt string may have been built with a filename

1381

# Sadly, the prompt string may have been built with a filename

1381

# containing "$$" so let's try to find the first valid-looking

1382

# containing "$$" so let's try to find the first valid-looking

1382

# prompt to start parsing. Sadly, we also can't rely on

1383

# prompt to start parsing. Sadly, we also can't rely on

1383

# choices containing spaces, ASCII, or basically anything

1384

# choices containing spaces, ASCII, or basically anything

1384

# except an ampersand followed by a character.

1385

# except an ampersand followed by a character.

1385

m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt)

1386

m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt)

1386

msg = m.group(1)

1387

msg = m.group(1)

1387

choices = [p.strip(' ') for p in m.group(2).split('$$')]

1388

choices = [p.strip(' ') for p in m.group(2).split('$$')]

1388

def choicetuple(s):

1389

def choicetuple(s):

1389

ampidx = s.index('&')

1390

ampidx = s.index('&')

1390

return s[ampidx + 1:ampidx + 2].lower(), s.replace('&', '', 1)

1391

return s[ampidx + 1:ampidx + 2].lower(), s.replace('&', '', 1)

1391

return (msg, [choicetuple(s) for s in choices])

1392

return (msg, [choicetuple(s) for s in choices])

1392

1393

def promptchoice(self, prompt, default=0):

1394

def promptchoice(self, prompt, default=0):

1394

"""Prompt user with a message, read response, and ensure it matches

1395

"""Prompt user with a message, read response, and ensure it matches

1395

one of the provided choices. The prompt is formatted as follows:

1396

one of the provided choices. The prompt is formatted as follows:

1396

1397

"would you like fries with that (Yn)? $$ &Yes $$ &No"

1398

"would you like fries with that (Yn)? $$ &Yes $$ &No"

1398

1399

The index of the choice is returned. Responses are case

1400

The index of the choice is returned. Responses are case

1400

insensitive. If ui is not interactive, the default is

1401

insensitive. If ui is not interactive, the default is

1401

returned.

1402

returned.

1402

"""

1403

"""

1403

1404

msg, choices = self.extractchoices(prompt)

1405

msg, choices = self.extractchoices(prompt)

1405

resps = [r for r, t in choices]

1406

resps = [r for r, t in choices]

1406

while True:

1407

while True:

1407

r = self.prompt(msg, resps[default])

1408

r = self.prompt(msg, resps[default])

1408

if r.lower() in resps:

1409

if r.lower() in resps:

1409

return resps.index(r.lower())

1410

return resps.index(r.lower())

1410

self.write(_("unrecognized response\n"))

1411

self.write(_("unrecognized response\n"))

1411

1412

def getpass(self, prompt=None, default=None):

1413

def getpass(self, prompt=None, default=None):

1413

if not self.interactive():

1414

if not self.interactive():

1414

return default

1415

return default

1415

try:

1416

try:

1416

self.write_err(self.label(prompt or _('password: '), 'ui.prompt'))

1417

self.write_err(self.label(prompt or _('password: '), 'ui.prompt'))

1417

# disable getpass() only if explicitly specified. it's still valid

1418

# disable getpass() only if explicitly specified. it's still valid

1418

# to interact with tty even if fin is not a tty.

1419

# to interact with tty even if fin is not a tty.

1419

with self.timeblockedsection('stdio'):

1420

with self.timeblockedsection('stdio'):

1420

if self.configbool('ui', 'nontty'):

1421

if self.configbool('ui', 'nontty'):

1421

l = self.fin.readline()

1422

l = self.fin.readline()

1422

if not l:

1423

if not l:

1423

raise EOFError

1424

raise EOFError

1424

return l.rstrip('\n')

1425

return l.rstrip('\n')

1425

else:

1426

else:

1426

return getpass.getpass('')

1427

return getpass.getpass('')

1427

except EOFError:

1428

except EOFError:

1428

raise error.ResponseExpected()

1429

raise error.ResponseExpected()

1429

1430

def status(self, *msg, **opts):

1431

def status(self, *msg, **opts):

1431

'''write status message to output (if ui.quiet is False)

1432

'''write status message to output (if ui.quiet is False)

1432

1433

This adds an output label of "ui.status".

1434

This adds an output label of "ui.status".

1434

'''

1435

'''

1435

if not self.quiet:

1436

if not self.quiet:

1436

opts[r'label'] = opts.get(r'label', '') + ' ui.status'

1437

opts[r'label'] = opts.get(r'label', '') + ' ui.status'

1437

self.write(*msg, **opts)

1438

self.write(*msg, **opts)

1438

1439

def warn(self, *msg, **opts):

1440

def warn(self, *msg, **opts):

1440

'''write warning message to output (stderr)

1441

'''write warning message to output (stderr)

1441

1442

This adds an output label of "ui.warning".

1443

This adds an output label of "ui.warning".

1443

'''

1444

'''

1444

opts[r'label'] = opts.get(r'label', '') + ' ui.warning'

1445

opts[r'label'] = opts.get(r'label', '') + ' ui.warning'

1445

self.write_err(*msg, **opts)

1446

self.write_err(*msg, **opts)

1446

1447

def error(self, *msg, **opts):

1448

def error(self, *msg, **opts):

1448

'''write error message to output (stderr)

1449

'''write error message to output (stderr)

1449

1450

This adds an output label of "ui.error".

1451

This adds an output label of "ui.error".

1451

'''

1452

'''

1452

opts[r'label'] = opts.get(r'label', '') + ' ui.error'

1453

opts[r'label'] = opts.get(r'label', '') + ' ui.error'

1453

self.write_err(*msg, **opts)

1454

self.write_err(*msg, **opts)

1454

1455

def note(self, *msg, **opts):

1456

def note(self, *msg, **opts):

1456

'''write note to output (if ui.verbose is True)

1457

'''write note to output (if ui.verbose is True)

1457

1458

This adds an output label of "ui.note".

1459

This adds an output label of "ui.note".

1459

'''

1460

'''

1460

if self.verbose:

1461

if self.verbose:

1461

opts[r'label'] = opts.get(r'label', '') + ' ui.note'

1462

opts[r'label'] = opts.get(r'label', '') + ' ui.note'

1462

self.write(*msg, **opts)

1463

self.write(*msg, **opts)

1463

1464

def debug(self, *msg, **opts):

1465

def debug(self, *msg, **opts):

1465

'''write debug message to output (if ui.debugflag is True)

1466

'''write debug message to output (if ui.debugflag is True)

1466

1467

This adds an output label of "ui.debug".

1468

This adds an output label of "ui.debug".

1468

'''

1469

'''

1469

if self.debugflag:

1470

if self.debugflag:

1470

opts[r'label'] = opts.get(r'label', '') + ' ui.debug'

1471

opts[r'label'] = opts.get(r'label', '') + ' ui.debug'

1471

self.write(*msg, **opts)

1472

self.write(*msg, **opts)

1472

1473

def edit(self, text, user, extra=None, editform=None, pending=None,

1474

def edit(self, text, user, extra=None, editform=None, pending=None,

1474

repopath=None, action=None):

1475

repopath=None, action=None):

1475

if action is None:

1476

if action is None:

1476

self.develwarn('action is None but will soon be a required '

1477

self.develwarn('action is None but will soon be a required '

1477

'parameter to ui.edit()')

1478

'parameter to ui.edit()')

1478

extra_defaults = {

1479

extra_defaults = {

1479

'prefix': 'editor',

1480

'prefix': 'editor',

1480

'suffix': '.txt',

1481

'suffix': '.txt',

1481

}

1482

}

1482

if extra is not None:

1483

if extra is not None:

1483

if extra.get('suffix') is not None:

1484

if extra.get('suffix') is not None:

1484

self.develwarn('extra.suffix is not None but will soon be '

1485

self.develwarn('extra.suffix is not None but will soon be '

1485

'ignored by ui.edit()')

1486

'ignored by ui.edit()')

1486

extra_defaults.update(extra)

1487

extra_defaults.update(extra)

1487

extra = extra_defaults

1488

extra = extra_defaults

1488

1489

if action == 'diff':

1490

if action == 'diff':

1490

suffix = '.diff'

1491

suffix = '.diff'

1491

elif action:

1492

elif action:

1492

suffix = '.%s.hg.txt' % action

1493

suffix = '.%s.hg.txt' % action

1493

else:

1494

else:

1494

suffix = extra['suffix']

1495

suffix = extra['suffix']

1495

1496

rdir = None

1497

rdir = None

1497

if self.configbool('experimental', 'editortmpinhg'):

1498

if self.configbool('experimental', 'editortmpinhg'):

1498

rdir = repopath

1499

rdir = repopath

1499

(fd, name) = pycompat.mkstemp(prefix='hg-' + extra['prefix'] + '-',

1500

(fd, name) = pycompat.mkstemp(prefix='hg-' + extra['prefix'] + '-',

1500

suffix=suffix,

1501

suffix=suffix,

1501

dir=rdir)

1502

dir=rdir)

1502

try:

1503

try:

1503

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

1504

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

1504

f.write(util.tonativeeol(text))

1505

f.write(util.tonativeeol(text))

1505

f.close()

1506

f.close()

1506

1507

environ = {'HGUSER': user}

1508

environ = {'HGUSER': user}

1508

if 'transplant_source' in extra:

1509

if 'transplant_source' in extra:

1509

environ.update({'HGREVISION': hex(extra['transplant_source'])})

1510

environ.update({'HGREVISION': hex(extra['transplant_source'])})

1510

for label in ('intermediate-source', 'source', 'rebase_source'):

1511

for label in ('intermediate-source', 'source', 'rebase_source'):

1511

if label in extra:

1512

if label in extra:

1512

environ.update({'HGREVISION': extra[label]})

1513

environ.update({'HGREVISION': extra[label]})

1513

break

1514

break

1514

if editform:

1515

if editform:

1515

environ.update({'HGEDITFORM': editform})

1516

environ.update({'HGEDITFORM': editform})

1516

if pending:

1517

if pending:

1517

environ.update({'HG_PENDING': pending})

1518

environ.update({'HG_PENDING': pending})

1518

1519

editor = self.geteditor()

1520

editor = self.geteditor()

1520

1521

self.system("%s \"%s\"" % (editor, name),

1522

self.system("%s \"%s\"" % (editor, name),

1522

environ=environ,

1523

environ=environ,

1523

onerr=error.Abort, errprefix=_("edit failed"),

1524

onerr=error.Abort, errprefix=_("edit failed"),

1524

blockedtag='editor')

1525

blockedtag='editor')

1525

1526

f = open(name, r'rb')

1527

f = open(name, r'rb')

1527

t = util.fromnativeeol(f.read())

1528

t = util.fromnativeeol(f.read())

1528

f.close()

1529

f.close()

1529

finally:

1530

finally:

1530

os.unlink(name)

1531

os.unlink(name)

1531

1532

return t

1533

return t

1533

1534

def system(self, cmd, environ=None, cwd=None, onerr=None, errprefix=None,

1535

def system(self, cmd, environ=None, cwd=None, onerr=None, errprefix=None,

1535

blockedtag=None):

1536

blockedtag=None):

1536

'''execute shell command with appropriate output stream. command

1537

'''execute shell command with appropriate output stream. command

1537

output will be redirected if fout is not stdout.

1538

output will be redirected if fout is not stdout.

1538

1539

if command fails and onerr is None, return status, else raise onerr

1540

if command fails and onerr is None, return status, else raise onerr

1540

object as exception.

1541

object as exception.

1541

'''

1542

'''

1542

if blockedtag is None:

1543

if blockedtag is None:

1543

# Long cmds tend to be because of an absolute path on cmd. Keep

1544

# Long cmds tend to be because of an absolute path on cmd. Keep

1544

# the tail end instead

1545

# the tail end instead

1545

cmdsuffix = cmd.translate(None, _keepalnum)[-85:]

1546

cmdsuffix = cmd.translate(None, _keepalnum)[-85:]

1546

blockedtag = 'unknown_system_' + cmdsuffix

1547

blockedtag = 'unknown_system_' + cmdsuffix

1547

out = self.fout

1548

out = self.fout

1548

if any(s[1] for s in self._bufferstates):

1549

if any(s[1] for s in self._bufferstates):

1549

out = self

1550

out = self

1550

with self.timeblockedsection(blockedtag):

1551

with self.timeblockedsection(blockedtag):

1551

rc = self._runsystem(cmd, environ=environ, cwd=cwd, out=out)

1552

rc = self._runsystem(cmd, environ=environ, cwd=cwd, out=out)

1552

if rc and onerr:

1553

if rc and onerr:

1553

errmsg = '%s %s' % (os.path.basename(cmd.split(None, 1)[0]),

1554

errmsg = '%s %s' % (os.path.basename(cmd.split(None, 1)[0]),

1554

procutil.explainexit(rc))

1555

procutil.explainexit(rc))

1555

if errprefix:

1556

if errprefix:

1556

errmsg = '%s: %s' % (errprefix, errmsg)

1557

errmsg = '%s: %s' % (errprefix, errmsg)

1557

raise onerr(errmsg)

1558

raise onerr(errmsg)

1558

return rc

1559

return rc

1559

1560

def _runsystem(self, cmd, environ, cwd, out):

1561

def _runsystem(self, cmd, environ, cwd, out):

1561

"""actually execute the given shell command (can be overridden by

1562

"""actually execute the given shell command (can be overridden by

1562

extensions like chg)"""

1563

extensions like chg)"""

1563

return procutil.system(cmd, environ=environ, cwd=cwd, out=out)

1564

return procutil.system(cmd, environ=environ, cwd=cwd, out=out)

1564

1565

def traceback(self, exc=None, force=False):

1566

def traceback(self, exc=None, force=False):

1566

'''print exception traceback if traceback printing enabled or forced.

1567

'''print exception traceback if traceback printing enabled or forced.

1567

only to call in exception handler. returns true if traceback

1568

only to call in exception handler. returns true if traceback

1568

printed.'''

1569

printed.'''

1569

if self.tracebackflag or force:

1570

if self.tracebackflag or force:

1570

if exc is None:

1571

if exc is None:

1571

exc = sys.exc_info()

1572

exc = sys.exc_info()

1572

cause = getattr(exc[1], 'cause', None)

1573

cause = getattr(exc[1], 'cause', None)

1573

1574

if cause is not None:

1575

if cause is not None:

1575

causetb = traceback.format_tb(cause[2])

1576

causetb = traceback.format_tb(cause[2])

1576

exctb = traceback.format_tb(exc[2])

1577

exctb = traceback.format_tb(exc[2])

1577

exconly = traceback.format_exception_only(cause[0], cause[1])

1578

exconly = traceback.format_exception_only(cause[0], cause[1])

1578

1579

# exclude frame where 'exc' was chained and rethrown from exctb

1580

# exclude frame where 'exc' was chained and rethrown from exctb

1580

self.write_err('Traceback (most recent call last):\n',

1581

self.write_err('Traceback (most recent call last):\n',

1581

''.join(exctb[:-1]),

1582

''.join(exctb[:-1]),

1582

''.join(causetb),

1583

''.join(causetb),

1583

''.join(exconly))

1584

''.join(exconly))

1584

else:

1585

else:

1585

output = traceback.format_exception(exc[0], exc[1], exc[2])

1586

output = traceback.format_exception(exc[0], exc[1], exc[2])

1586

self.write_err(encoding.strtolocal(r''.join(output)))

1587

self.write_err(encoding.strtolocal(r''.join(output)))

1587

return self.tracebackflag or force

1588

return self.tracebackflag or force

1588

1589

def geteditor(self):

1590

def geteditor(self):

1590

'''return editor to use'''

1591

'''return editor to use'''

1591

if pycompat.sysplatform == 'plan9':

1592

if pycompat.sysplatform == 'plan9':

1592

# vi is the MIPS instruction simulator on Plan 9. We

1593

# vi is the MIPS instruction simulator on Plan 9. We

1593

# instead default to E to plumb commit messages to

1594

# instead default to E to plumb commit messages to

1594

# avoid confusion.

1595

# avoid confusion.

1595

editor = 'E'

1596

editor = 'E'

1596

else:

1597

else:

1597

editor = 'vi'

1598

editor = 'vi'

1598

return (encoding.environ.get("HGEDITOR") or

1599

return (encoding.environ.get("HGEDITOR") or

1599

self.config("ui", "editor", editor))

1600

self.config("ui", "editor", editor))

1600

1601

@util.propertycache

1602

@util.propertycache

1602

def _progbar(self):

1603

def _progbar(self):

1603

"""setup the progbar singleton to the ui object"""

1604

"""setup the progbar singleton to the ui object"""

1604

if (self.quiet or self.debugflag

1605

if (self.quiet or self.debugflag

1605

or self.configbool('progress', 'disable')

1606

or self.configbool('progress', 'disable')

1606

or not progress.shouldprint(self)):

1607

or not progress.shouldprint(self)):

1607

return None

1608

return None

1608

return getprogbar(self)

1609

return getprogbar(self)

1609

1610

def _progclear(self):

1611

def _progclear(self):

1611

"""clear progress bar output if any. use it before any output"""

1612

"""clear progress bar output if any. use it before any output"""

1612

if not haveprogbar(): # nothing loaded yet

1613

if not haveprogbar(): # nothing loaded yet

1613

return

1614

return

1614

if self._progbar is not None and self._progbar.printed:

1615

if self._progbar is not None and self._progbar.printed:

1615

self._progbar.clear()

1616

self._progbar.clear()

1616

1617

def progress(self, topic, pos, item="", unit="", total=None):

1618

def progress(self, topic, pos, item="", unit="", total=None):

1618

'''show a progress message

1619

'''show a progress message

1619

1620

By default a textual progress bar will be displayed if an operation

1621

By default a textual progress bar will be displayed if an operation

1621

takes too long. 'topic' is the current operation, 'item' is a

1622

takes too long. 'topic' is the current operation, 'item' is a

1622

non-numeric marker of the current position (i.e. the currently

1623

non-numeric marker of the current position (i.e. the currently

1623

in-process file), 'pos' is the current numeric position (i.e.

1624

in-process file), 'pos' is the current numeric position (i.e.

1624

revision, bytes, etc.), unit is a corresponding unit label,

1625

revision, bytes, etc.), unit is a corresponding unit label,

1625

and total is the highest expected pos.

1626

and total is the highest expected pos.

1626

1627

Multiple nested topics may be active at a time.

1628

Multiple nested topics may be active at a time.

1628

1629

All topics should be marked closed by setting pos to None at

1630

All topics should be marked closed by setting pos to None at

1630

termination.

1631

termination.

1631

'''

1632

'''

1632

if self._progbar is not None:

1633

if self._progbar is not None:

1633

self._progbar.progress(topic, pos, item=item, unit=unit,

1634

self._progbar.progress(topic, pos, item=item, unit=unit,

1634

total=total)

1635

total=total)

1635

if pos is None or not self.configbool('progress', 'debug'):

1636

if pos is None or not self.configbool('progress', 'debug'):

1636

return

1637

return

1637

1638

if unit:

1639

if unit:

1639

unit = ' ' + unit

1640

unit = ' ' + unit

1640

if item:

1641

if item:

1641

item = ' ' + item

1642

item = ' ' + item

1642

1643

if total:

1644

if total:

1644

pct = 100.0 * pos / total

1645

pct = 100.0 * pos / total

1645

self.debug('%s:%s %d/%d%s (%4.2f%%)\n'

1646

self.debug('%s:%s %d/%d%s (%4.2f%%)\n'

1646

% (topic, item, pos, total, unit, pct))

1647

% (topic, item, pos, total, unit, pct))

1647

else:

1648

else:

1648

self.debug('%s:%s %d%s\n' % (topic, item, pos, unit))

1649

self.debug('%s:%s %d%s\n' % (topic, item, pos, unit))

1649

1650

def makeprogress(self, topic, unit="", total=None):

1651

def makeprogress(self, topic, unit="", total=None):

1651

'''exists only so low-level modules won't need to import scmutil'''

1652

'''exists only so low-level modules won't need to import scmutil'''

1652

return scmutil.progress(self, topic, unit, total)

1653

return scmutil.progress(self, topic, unit, total)

1653

1654

def log(self, service, *msg, **opts):

1655

def log(self, service, *msg, **opts):

1655

'''hook for logging facility extensions

1656

'''hook for logging facility extensions

1656

1657

service should be a readily-identifiable subsystem, which will

1658

service should be a readily-identifiable subsystem, which will

1658

allow filtering.

1659

allow filtering.

1659

1660

*msg should be a newline-terminated format string to log, and

1661

*msg should be a newline-terminated format string to log, and

1661

then any values to %-format into that format string.

1662

then any values to %-format into that format string.

1662

1663

**opts currently has no defined meanings.

1664

**opts currently has no defined meanings.

1664

'''

1665

'''

1665

1666

def label(self, msg, label):

1667

def label(self, msg, label):

1667

'''style msg based on supplied label

1668

'''style msg based on supplied label

1668

1669

If some color mode is enabled, this will add the necessary control

1670

If some color mode is enabled, this will add the necessary control

1670

characters to apply such color. In addition, 'debug' color mode adds

1671

characters to apply such color. In addition, 'debug' color mode adds

1671

markup showing which label affects a piece of text.

1672

markup showing which label affects a piece of text.

1672

1673

ui.write(s, 'label') is equivalent to

1674

ui.write(s, 'label') is equivalent to

1674

ui.write(ui.label(s, 'label')).

1675

ui.write(ui.label(s, 'label')).

1675

'''

1676

'''

1676

if self._colormode is not None:

1677

if self._colormode is not None:

1677

return color.colorlabel(self, msg, label)

1678

return color.colorlabel(self, msg, label)

1678

return msg

1679

return msg

1679

1680

def develwarn(self, msg, stacklevel=1, config=None):

1681

def develwarn(self, msg, stacklevel=1, config=None):

1681

"""issue a developer warning message

1682

"""issue a developer warning message

1682

1683

Use 'stacklevel' to report the offender some layers further up in the

1684

Use 'stacklevel' to report the offender some layers further up in the

1684

stack.

1685

stack.

1685

"""

1686

"""

1686

if not self.configbool('devel', 'all-warnings'):

1687

if not self.configbool('devel', 'all-warnings'):

1687

if config is None or not self.configbool('devel', config):

1688

if config is None or not self.configbool('devel', config):

1688

return

1689

return

1689

msg = 'devel-warn: ' + msg

1690

msg = 'devel-warn: ' + msg

1690

stacklevel += 1 # get in develwarn

1691

stacklevel += 1 # get in develwarn

1691

if self.tracebackflag:

1692

if self.tracebackflag:

1692

util.debugstacktrace(msg, stacklevel, self.ferr, self.fout)

1693

util.debugstacktrace(msg, stacklevel, self.ferr, self.fout)

1693

self.log('develwarn', '%s at:\n%s' %

1694

self.log('develwarn', '%s at:\n%s' %

1694

(msg, ''.join(util.getstackframes(stacklevel))))

1695

(msg, ''.join(util.getstackframes(stacklevel))))

1695

else:

1696

else:

1696

curframe = inspect.currentframe()

1697

curframe = inspect.currentframe()

1697

calframe = inspect.getouterframes(curframe, 2)

1698

calframe = inspect.getouterframes(curframe, 2)

1698

fname, lineno, fmsg = calframe[stacklevel][1:4]

1699

fname, lineno, fmsg = calframe[stacklevel][1:4]

1699

fname, fmsg = pycompat.sysbytes(fname), pycompat.sysbytes(fmsg)

1700

fname, fmsg = pycompat.sysbytes(fname), pycompat.sysbytes(fmsg)

1700

self.write_err('%s at: %s:%d (%s)\n'

1701

self.write_err('%s at: %s:%d (%s)\n'

1701

% (msg, fname, lineno, fmsg))

1702

% (msg, fname, lineno, fmsg))

1702

self.log('develwarn', '%s at: %s:%d (%s)\n',

1703

self.log('develwarn', '%s at: %s:%d (%s)\n',

1703

msg, fname, lineno, fmsg)

1704

msg, fname, lineno, fmsg)

1704

curframe = calframe = None # avoid cycles

1705

curframe = calframe = None # avoid cycles

1705

1706

def deprecwarn(self, msg, version, stacklevel=2):

1707

def deprecwarn(self, msg, version, stacklevel=2):

1707

"""issue a deprecation warning

1708

"""issue a deprecation warning

1708

1709

- msg: message explaining what is deprecated and how to upgrade,

1710

- msg: message explaining what is deprecated and how to upgrade,

1710

- version: last version where the API will be supported,

1711

- version: last version where the API will be supported,

1711

"""

1712

"""

1712

if not (self.configbool('devel', 'all-warnings')

1713

if not (self.configbool('devel', 'all-warnings')

1713

or self.configbool('devel', 'deprec-warn')):

1714

or self.configbool('devel', 'deprec-warn')):

1714

return

1715

return

1715

msg += ("\n(compatibility will be dropped after Mercurial-%s,"

1716

msg += ("\n(compatibility will be dropped after Mercurial-%s,"

1716

" update your code.)") % version

1717

" update your code.)") % version

1717

self.develwarn(msg, stacklevel=stacklevel, config='deprec-warn')

1718

self.develwarn(msg, stacklevel=stacklevel, config='deprec-warn')

1718

1719

def exportableenviron(self):

1720

def exportableenviron(self):

1720

"""The environment variables that are safe to export, e.g. through

1721

"""The environment variables that are safe to export, e.g. through

1721

hgweb.

1722

hgweb.

1722

"""

1723

"""

1723

return self._exportableenviron

1724

return self._exportableenviron

1724

1725

@contextlib.contextmanager

1726

@contextlib.contextmanager

1726

def configoverride(self, overrides, source=""):

1727

def configoverride(self, overrides, source=""):

1727

"""Context manager for temporary config overrides

1728

"""Context manager for temporary config overrides

1728

`overrides` must be a dict of the following structure:

1729

`overrides` must be a dict of the following structure:

1729

{(section, name) : value}"""

1730

{(section, name) : value}"""

1730

backups = {}

1731

backups = {}

1731

try:

1732

try:

1732

for (section, name), value in overrides.items():

1733

for (section, name), value in overrides.items():

1733

backups[(section, name)] = self.backupconfig(section, name)

1734

backups[(section, name)] = self.backupconfig(section, name)

1734

self.setconfig(section, name, value, source)

1735

self.setconfig(section, name, value, source)

1735

yield

1736

yield

1736

finally:

1737

finally:

1737

for __, backup in backups.items():

1738

for __, backup in backups.items():

1738

self.restoreconfig(backup)

1739

self.restoreconfig(backup)

1739

# just restoring ui.quiet config to the previous value is not enough

1740

# just restoring ui.quiet config to the previous value is not enough

1740

# as it does not update ui.quiet class member

1741

# as it does not update ui.quiet class member

1741

if ('ui', 'quiet') in overrides:

1742

if ('ui', 'quiet') in overrides:

1742

self.fixconfig(section='ui')

1743

self.fixconfig(section='ui')

1743

1744

class paths(dict):

1745

class paths(dict):

1745

"""Represents a collection of paths and their configs.

1746

"""Represents a collection of paths and their configs.

1746

1747

Data is initially derived from ui instances and the config files they have

1748

Data is initially derived from ui instances and the config files they have

1748

loaded.

1749

loaded.

1749

"""

1750

"""

1750

def __init__(self, ui):

1751

def __init__(self, ui):

1751

dict.__init__(self)

1752

dict.__init__(self)

1752

1753

for name, loc in ui.configitems('paths', ignoresub=True):

1754

for name, loc in ui.configitems('paths', ignoresub=True):

1754

# No location is the same as not existing.

1755

# No location is the same as not existing.

1755

if not loc:

1756

if not loc:

1756

continue

1757

continue

1757

loc, sub = ui.configsuboptions('paths', name)

1758

loc, sub = ui.configsuboptions('paths', name)

1758

self[name] = path(ui, name, rawloc=loc, suboptions=sub)

1759

self[name] = path(ui, name, rawloc=loc, suboptions=sub)

1759

1760

def getpath(self, name, default=None):

1761

def getpath(self, name, default=None):

1761

"""Return a ``path`` from a string, falling back to default.

1762

"""Return a ``path`` from a string, falling back to default.

1762

1763

``name`` can be a named path or locations. Locations are filesystem

1764

``name`` can be a named path or locations. Locations are filesystem

1764

paths or URIs.

1765

paths or URIs.

1765

1766

Returns None if ``name`` is not a registered path, a URI, or a local

1767

Returns None if ``name`` is not a registered path, a URI, or a local

1767

path to a repo.

1768

path to a repo.

1768

"""

1769

"""

1769

# Only fall back to default if no path was requested.

1770

# Only fall back to default if no path was requested.

1770

if name is None:

1771

if name is None:

1771

if not default:

1772

if not default:

1772

default = ()

1773

default = ()

1773

elif not isinstance(default, (tuple, list)):

1774

elif not isinstance(default, (tuple, list)):

1774

default = (default,)

1775

default = (default,)

1775

for k in default:

1776

for k in default:

1776

try:

1777

try:

1777

return self[k]

1778

return self[k]

1778

except KeyError:

1779

except KeyError:

1779

continue

1780

continue

1780

return None

1781

return None

1781

1782

# Most likely empty string.

1783

# Most likely empty string.

1783

# This may need to raise in the future.

1784

# This may need to raise in the future.

1784

if not name:

1785

if not name:

1785

return None

1786

return None

1786

1787

try:

1788

try:

1788

return self[name]

1789

return self[name]

1789

except KeyError:

1790

except KeyError:

1790

# Try to resolve as a local path or URI.

1791

# Try to resolve as a local path or URI.

1791

try:

1792

try:

1792

# We don't pass sub-options in, so no need to pass ui instance.

1793

# We don't pass sub-options in, so no need to pass ui instance.

1793

return path(None, None, rawloc=name)

1794

return path(None, None, rawloc=name)

1794

except ValueError:

1795

except ValueError:

1795

raise error.RepoError(_('repository %s does not exist') %

1796

raise error.RepoError(_('repository %s does not exist') %

1796

name)

1797

name)

1797

1798

_pathsuboptions = {}

1799

_pathsuboptions = {}

1799

1800

def pathsuboption(option, attr):

1801

def pathsuboption(option, attr):

1801

"""Decorator used to declare a path sub-option.

1802

"""Decorator used to declare a path sub-option.

1802

1803

Arguments are the sub-option name and the attribute it should set on

1804

Arguments are the sub-option name and the attribute it should set on

1804

``path`` instances.

1805

``path`` instances.

1805

1806

The decorated function will receive as arguments a ``ui`` instance,

1807

The decorated function will receive as arguments a ``ui`` instance,

1807

``path`` instance, and the string value of this option from the config.

1808

``path`` instance, and the string value of this option from the config.

1808

The function should return the value that will be set on the ``path``

1809

The function should return the value that will be set on the ``path``

1809

instance.

1810

instance.

1810

1811

This decorator can be used to perform additional verification of

1812

This decorator can be used to perform additional verification of

1812

sub-options and to change the type of sub-options.

1813

sub-options and to change the type of sub-options.

1813

"""

1814

"""

1814

def register(func):

1815

def register(func):

1815

_pathsuboptions[option] = (attr, func)

1816

_pathsuboptions[option] = (attr, func)

1816

return func

1817

return func

1817

return register

1818

return register

1818

1819

@pathsuboption('pushurl', 'pushloc')

1820

@pathsuboption('pushurl', 'pushloc')

1820

def pushurlpathoption(ui, path, value):

1821

def pushurlpathoption(ui, path, value):

1821

u = util.url(value)

1822

u = util.url(value)

1822

# Actually require a URL.

1823

# Actually require a URL.

1823

if not u.scheme:

1824

if not u.scheme:

1824

ui.warn(_('(paths.%s:pushurl not a URL; ignoring)\n') % path.name)

1825

ui.warn(_('(paths.%s:pushurl not a URL; ignoring)\n') % path.name)

1825

return None

1826

return None

1826

1827

# Don't support the #foo syntax in the push URL to declare branch to

1828

# Don't support the #foo syntax in the push URL to declare branch to

1828

# push.

1829

# push.

1829

if u.fragment:

1830

if u.fragment:

1830

ui.warn(_('("#fragment" in paths.%s:pushurl not supported; '

1831

ui.warn(_('("#fragment" in paths.%s:pushurl not supported; '

1831

'ignoring)\n') % path.name)

1832

'ignoring)\n') % path.name)

1832

u.fragment = None

1833

u.fragment = None

1833

1834

return bytes(u)

1835

return bytes(u)

1835

1836

@pathsuboption('pushrev', 'pushrev')

1837

@pathsuboption('pushrev', 'pushrev')

1837

def pushrevpathoption(ui, path, value):

1838

def pushrevpathoption(ui, path, value):

1838

return value

1839

return value

1839

1840

class path(object):

1841

class path(object):

1841

"""Represents an individual path and its configuration."""

1842

"""Represents an individual path and its configuration."""

1842

1843

def __init__(self, ui, name, rawloc=None, suboptions=None):

1844

def __init__(self, ui, name, rawloc=None, suboptions=None):

1844

"""Construct a path from its config options.

1845

"""Construct a path from its config options.

1845

1846

``ui`` is the ``ui`` instance the path is coming from.

1847

``ui`` is the ``ui`` instance the path is coming from.

1847

``name`` is the symbolic name of the path.

1848

``name`` is the symbolic name of the path.

1848

``rawloc`` is the raw location, as defined in the config.

1849

``rawloc`` is the raw location, as defined in the config.

1849

``pushloc`` is the raw locations pushes should be made to.

1850

``pushloc`` is the raw locations pushes should be made to.

1850

1851

If ``name`` is not defined, we require that the location be a) a local

1852

If ``name`` is not defined, we require that the location be a) a local

1852

filesystem path with a .hg directory or b) a URL. If not,

1853

filesystem path with a .hg directory or b) a URL. If not,

1853

``ValueError`` is raised.

1854

``ValueError`` is raised.

1854

"""

1855

"""

1855

if not rawloc:

1856

if not rawloc:

1856

raise ValueError('rawloc must be defined')

1857

raise ValueError('rawloc must be defined')

1857

1858

# Locations may define branches via syntax <base>#<branch>.

1859

# Locations may define branches via syntax <base>#<branch>.

1859

u = util.url(rawloc)

1860

u = util.url(rawloc)

1860

branch = None

1861

branch = None

1861

if u.fragment:

1862

if u.fragment:

1862

branch = u.fragment

1863

branch = u.fragment

1863

u.fragment = None

1864

u.fragment = None

1864

1865

self.url = u

1866

self.url = u

1866

self.branch = branch

1867

self.branch = branch

1867

1868

self.name = name

1869

self.name = name

1869

self.rawloc = rawloc

1870

self.rawloc = rawloc

1870

self.loc = '%s' % u

1871

self.loc = '%s' % u

1871

1872

# When given a raw location but not a symbolic name, validate the

1873

# When given a raw location but not a symbolic name, validate the

1873

# location is valid.

1874

# location is valid.

1874

if not name and not u.scheme and not self._isvalidlocalpath(self.loc):

1875

if not name and not u.scheme and not self._isvalidlocalpath(self.loc):

1875

raise ValueError('location is not a URL or path to a local '

1876

raise ValueError('location is not a URL or path to a local '

1876

'repo: %s' % rawloc)

1877

'repo: %s' % rawloc)

1877

1878

suboptions = suboptions or {}

1879

suboptions = suboptions or {}

1879

1880

# Now process the sub-options. If a sub-option is registered, its

1881

# Now process the sub-options. If a sub-option is registered, its

1881

# attribute will always be present. The value will be None if there

1882

# attribute will always be present. The value will be None if there

1882

# was no valid sub-option.

1883

# was no valid sub-option.

1883

for suboption, (attr, func) in _pathsuboptions.iteritems():

1884

for suboption, (attr, func) in _pathsuboptions.iteritems():

1884

if suboption not in suboptions:

1885

if suboption not in suboptions:

1885

setattr(self, attr, None)

1886

setattr(self, attr, None)

1886

continue

1887

continue

1887

1888

value = func(ui, self, suboptions[suboption])

1889

value = func(ui, self, suboptions[suboption])

1889

setattr(self, attr, value)

1890

setattr(self, attr, value)

1890

1891

def _isvalidlocalpath(self, path):

1892

def _isvalidlocalpath(self, path):

1892

"""Returns True if the given path is a potentially valid repository.

1893

"""Returns True if the given path is a potentially valid repository.

1893

This is its own function so that extensions can change the definition of

1894

This is its own function so that extensions can change the definition of

1894

'valid' in this case (like when pulling from a git repo into a hg

1895

'valid' in this case (like when pulling from a git repo into a hg

1895

one)."""

1896

one)."""

1896

return os.path.isdir(os.path.join(path, '.hg'))

1897

return os.path.isdir(os.path.join(path, '.hg'))

1897

1898

@property

1899

@property

1899

def suboptions(self):

1900

def suboptions(self):

1900

"""Return sub-options and their values for this path.

1901

"""Return sub-options and their values for this path.

1901

1902

This is intended to be used for presentation purposes.

1903

This is intended to be used for presentation purposes.

1903

"""

1904

"""

1904

d = {}

1905

d = {}

1905

for subopt, (attr, _func) in _pathsuboptions.iteritems():

1906

for subopt, (attr, _func) in _pathsuboptions.iteritems():

1906

value = getattr(self, attr)

1907

value = getattr(self, attr)

1907

if value is not None:

1908

if value is not None:

1908

d[subopt] = value

1909

d[subopt] = value

1909

return d

1910

return d

1910

1911

# we instantiate one globally shared progress bar to avoid

1912

# we instantiate one globally shared progress bar to avoid

1912

# competing progress bars when multiple UI objects get created

1913

# competing progress bars when multiple UI objects get created

1913

_progresssingleton = None

1914

_progresssingleton = None

1914

1915

def getprogbar(ui):

1916

def getprogbar(ui):

1916

global _progresssingleton

1917

global _progresssingleton

1917

if _progresssingleton is None:

1918

if _progresssingleton is None:

1918

# passing 'ui' object to the singleton is fishy,

1919

# passing 'ui' object to the singleton is fishy,

1919

# this is how the extension used to work but feel free to rework it.

1920

# this is how the extension used to work but feel free to rework it.

1920

_progresssingleton = progress.progbar(ui)

1921

_progresssingleton = progress.progbar(ui)

1921

return _progresssingleton

1922

return _progresssingleton

1922

1923

def haveprogbar():

1924

def haveprogbar():

1924

return _progresssingleton is not None

1925

return _progresssingleton is not None

	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-absorb-filefixupstate.py
             test-absorb-phase.t
             test-absorb-rename.t
             test-absorb-strip.t
             test-absorb.t
             test-add.t
             test-addremove-similar.t
             test-addremove.t
             test-alias.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-bad-pull.t
             test-basic.t
             test-bdiff.py
             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-pushpull.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-r.t
             test-bundle-type.t
             test-bundle-vs-outgoing.t
             test-bundle.t
             test-bundle2-exchange.t
             test-bundle2-format.t
             test-bundle2-multiple-changegroups.t
             test-bundle2-pushback.t
             test-bundle2-remote-changegroup.t
             test-cappedreader.py
             test-casecollision.t
             test-cat.t
             test-cbor.py
             test-censor.t
             test-changelog-exec.t
             test-check-code.t
             test-check-commit.t
             test-check-execute.t
             test-check-interfaces.py
             test-check-module-imports.t
             test-check-py3-compat.t
             test-check-pyflakes.t
             test-check-pylint.t
             test-check-shbang.t
             test-children.t
             test-clone-cgi.t
             test-clone-pull-corruption.t
             test-clone-r.t
             test-clone-uncompressed.t
             test-clone-update-order.t
             test-clone.t
             test-clonebundles.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-context.py
             test-contrib-check-code.t
             test-contrib-check-commit.t
             test-contrib-dumprevlog.t
             test-contrib-perf.t
             test-contrib-testparseutil.t
             test-convert-authormap.t
             test-convert-clonebranches.t
             test-convert-cvs-branch.t
             test-convert-cvs-detectmerge.t
             test-convert-cvs-synthetic.t
             test-convert-cvs.t
             test-convert-cvsnt-mergepoints.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-convert-splicemap.t
             test-convert-tagsbranch-topology.t
             test-copy-move-merge.t
             test-copy.t
             test-copytrace-heuristics.t
             test-debugbuilddag.t
             test-debugbundle.t
             test-debugcommands.t
             test-debugextensions.t
             test-debugindexdot.t
             test-debugrename.t
             test-default-push.t
             test-diff-antipatience.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-diffstat.t
             test-directaccess.t
             test-dirstate-backup.t
             test-dirstate-nonnormalset.t
             test-dirstate.t
             test-dispatch.py
             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-patch.t
             test-eol-tag.t
             test-eol-update.t
             test-eol.t
             test-eolfilename.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-export.t
             test-extdata.t
             test-extdiff.t
             test-extensions-afterloaded.t
             test-extensions-wrapfunction.py
             test-extra-filelog-entry.t
             test-fetch.t
             test-filebranch.t
             test-filecache.py
             test-filelog.py
             test-fileset-generated.t
             test-fileset.t
             test-fix-topology.t
             test-flags.t
             test-generaldelta.t
             test-getbundle.t
             test-git-export.t
             test-globalopts.t
             test-glog-beautifygraph.t
             test-glog-topological.t
             test-glog.t
             test-gpg.t
             test-graft.t
             test-grep.t
             test-hg-parseurl.py
             test-hghave.t
             test-hgignore.t
             test-hgk.t
             test-hgrc.t
             test-hgweb-annotate-whitespace.t
             test-hgweb-bundle.t
             test-hgweb-csp.t
             test-hgweb-descend-empties.t
             test-hgweb-diffs.t
             test-hgweb-empty.t
             test-hgweb-filelog.t
             test-hgweb-non-interactive.t
             test-hgweb-raw.t
             test-hgweb-removed.t
             test-hgweb.t
             test-hgwebdir-paths.py
             test-hgwebdirsym.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-backup.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-http-permissions.t
             test-http.t
             test-hybridencode.py
             test-i18n.t
             test-identify.t
             test-impexp-branch.t
             test-import-bypass.t
             test-import-eol.t
             test-import-merge.t
             test-import-unknown.t
             test-import.t
             test-imports-checker.t
             test-incoming-outgoing.t
             test-inherit-mode.t
             test-init.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-issue5979.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-known.t
             test-largefiles-cache.t
             test-largefiles-misc.t
             test-largefiles-small-disk.t
             test-largefiles-update.t
             test-largefiles.t
             test-lfs-largefiles.t
             test-lfs-pointer.py
             test-linelog.py
             test-linerange.py
             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-no-file-change.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-minifileset.py
             test-minirst.py
             test-mq-git.t
             test-mq-guards.t
             test-mq-header-date.t
             test-mq-header-from.t
             test-mq-merge.t
             test-mq-pull-from-bundle.t
             test-mq-qclone-http.t
             test-mq-qdelete.t
             test-mq-qdiff.t
             test-mq-qfold.t
             test-mq-qgoto.t
             test-mq-qimport-fail-cleanup.t
             test-mq-qnew.t
             test-mq-qpush-exact.t
             test-mq-qpush-fail.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-mq.t
             test-mv-cp-st-diff.t
             test-narrow-acl.t
             test-narrow-archive.t
             test-narrow-clone-no-ellipsis.t
             test-narrow-clone-non-narrow-server.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-trackedcmd.t
             test-narrow-update.t
             test-narrow-widen-no-ellipsis.t
             test-narrow-widen.t
             test-narrow.t
             test-nested-repo.t
             test-newbranch.t
             test-newercgi.t
             test-nointerrupt.t
             test-obshistory.t
             test-obsmarker-template.t
             test-obsmarkers-effectflag.t
             test-obsolete-bounds-checking.t
             test-obsolete-bundle-strip.t
             test-obsolete-changeset-exchange.t
             test-obsolete-checkheads.t
             test-obsolete-distributed.t
             test-obsolete-divergent.t
             test-obsolete-tag-cache.t
             test-obsolete.t
+            test-pager-legacy.t
             test-pager.t
             test-parents.t
             test-parseindex2.py
             test-patch-offset.t
             test-patch.t
             test-patchbomb-bookmark.t
             test-patchbomb-tls.t
             test-patchbomb.t
             test-pathconflicts-merge.t
             test-pathconflicts-update.t
             test-pathencode.py
             test-pending.t
             test-permissions.t
             test-phases-exchange.t
             test-phases.t
             test-progress.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-pull.t
             test-purge.t
             test-push-cgi.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-push.t
             test-pushvars.t
             test-qrecord.t
             test-rebase-abort.t
             test-rebase-backup.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-mq.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-rebuildstate.t
             test-record.t
             test-relink.t
             test-remove.t
             test-removeemptydirs.t
             test-rename-after-merge.t
             test-rename-dir-merge.t
             test-rename-merge1.t
             test-rename-merge2.t
             test-rename.t
             test-repair-strip.t
             test-repo-compengines.t
             test-resolve.t
             test-revert-flags.t
             test-revert-interactive.t
             test-revert-unknown.t
             test-revert.t
             test-revisions.t
             test-revlog-ancestry.py
             test-revlog-group-emptyiter.t
             test-revlog-mmapindex.t
             test-revlog-packentry.t
             test-revlog-raw.py
             test-revlog-v2.t
             test-revset-dirstate-parents.t
             test-revset-legacy-lookup.t
             test-revset-outgoing.t
             test-rollback.t
             test-run-tests.py
             test-run-tests.t
             test-schemes.t
             test-serve.t
             test-setdiscovery.t
             test-share.t
             test-shelve.t
             test-show-stack.t
             test-show-work.t
             test-show.t
             test-simple-update.t
             test-simplekeyvaluefile.py
             test-simplemerge.py
             test-single-head.t
             test-sparse-clear.t
             test-sparse-clone.t
             test-sparse-import.t
             test-sparse-merges.t
             test-sparse-profiles.t
             test-sparse-requirement.t
             test-sparse-verbose-json.t
             test-sparse.t
             test-split.t
             test-ssh-bundle1.t
             test-ssh-clone-r.t
             test-ssh-proto-unbundle.t
             test-ssh-proto.t
             test-ssh.t
             test-sshserver.py
             test-stack.t
             test-status-color.t
             test-status-inprocess.py
             test-status-rev.t
             test-status-terse.t
             test-storage.py
             test-stream-bundle-v2.t
             test-strict.t
             test-strip-cross.t
             test-strip.t
             test-subrepo-deep-nested-change.t
             test-subrepo-missing.t
             test-subrepo-paths.t
             test-subrepo-recursion.t
             test-subrepo-relative-path.t
             test-subrepo.t
             test-symlink-os-yes-fs-no.py
             test-symlink-placeholder.t
             test-symlinks.t
             test-tag.t
             test-tags.t
             test-template-basic.t
             test-template-functions.t
             test-template-keywords.t
             test-template-map.t
             test-transplant.t
             test-treemanifest.t
             test-ui-color.py
             test-ui-config.py
             test-ui-verbosity.py
             test-unamend.t
             test-unbundlehash.t
             test-uncommit.t
             test-unified-test.t
             test-unionrepo.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-download.t
             test-url-rev.t
             test-url.py
             test-username-newline.t
             test-util.py
             test-verify.t
             test-walk.t
             test-walkrepo.py
             test-websub.t
             test-win32text.t
             test-wireproto-clientreactor.py
             test-wireproto-command-branchmap.t
             test-wireproto-command-changesetdata.t
             test-wireproto-command-filedata.t
             test-wireproto-command-filesdata.t
             test-wireproto-command-heads.t
             test-wireproto-command-listkeys.t
             test-wireproto-command-lookup.t
             test-wireproto-command-manifestdata.t
             test-wireproto-command-pushkey.t
             test-wireproto-framing.py
             test-wireproto-serverreactor.py
             test-wireproto.py
             test-wsgirequest.py
             test-xdg.t

             # ui.py - user interface bits for mercurial
             #
             # Copyright 2005-2007 Matt Mackall <mpm@selenic.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
             import collections
             import contextlib
             import errno
             import getpass
             import inspect
             import os
             import re
             import signal
             import socket
             import subprocess
             import sys
             import traceback
             from .i18n import _
             from .node import hex
             from . import (
                 color,
                 config,
                 configitems,
                 encoding,
                 error,
                 formatter,
                 progress,
                 pycompat,
                 rcutil,
                 scmutil,
                 util,
             )
             from .utils import (
                 dateutil,
                 procutil,
                 stringutil,
             )
             urlreq = util.urlreq
             # for use with str.translate(None, _keepalnum), to keep just alphanumerics
             _keepalnum = ''.join(c for c in map(pycompat.bytechr, range(256))
                                  if not c.isalnum())
             # The config knobs that will be altered (if unset) by ui.tweakdefaults.
             tweakrc = b"""
             [ui]
             # The rollback command is dangerous. As a rule, don't use it.
             rollback = False
             # Make `hg status` report copy information
             statuscopies = yes
             # Prefer curses UIs when available. Revert to plain-text with `text`.
             interface = curses
             [commands]
             # Grep working directory by default.
             grep.all-files = True
             # Make `hg status` emit cwd-relative paths by default.
             status.relative = yes
             # Refuse to perform an `hg update` that would cause a file content merge
             update.check = noconflict
             # Show conflicts information in `hg status`
             status.verbose = True
             # Refuse to perform `hg resolve --mark` on files that still have conflict
             # markers
             resolve.mark-check = abort
             [diff]
             git = 1
             showfunc = 1
             word-diff = 1
             """
             samplehgrcs = {
                 'user':
             b"""# example user config (see 'hg help config' for more info)
             [ui]
             # name and email, e.g.
             # username = Jane Doe <jdoe@example.com>
             username =
             # We recommend enabling tweakdefaults to get slight improvements to
             # the UI over time. Make sure to set HGPLAIN in the environment when
             # writing scripts!
             # tweakdefaults = True
             # uncomment to disable color in command output
             # (see 'hg help color' for details)
             # color = never
             # uncomment to disable command output pagination
             # (see 'hg help pager' for details)
             # paginate = never
             [extensions]
             # uncomment these lines to enable some popular extensions
             # (see 'hg help extensions' for more info)
             #
             # churn =
             """,
                 'cloned':
             b"""# example repository config (see 'hg help config' for more info)
             [paths]
             default = %s
             # path aliases to other clones of this repo in URLs or filesystem paths
             # (see 'hg help config.paths' for more info)
             #
             # default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork
             # my-fork         = ssh://jdoe@example.net/hg/jdoes-fork
             # my-clone        = /home/jdoe/jdoes-clone
             [ui]
             # name and email (local to this repository, optional), e.g.
             # username = Jane Doe <jdoe@example.com>
             """,
                 'local':
             b"""# example repository config (see 'hg help config' for more info)
             [paths]
             # path aliases to other clones of this repo in URLs or filesystem paths
             # (see 'hg help config.paths' for more info)
             #
             # default         = http://example.com/hg/example-repo
             # default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork
             # my-fork         = ssh://jdoe@example.net/hg/jdoes-fork
             # my-clone        = /home/jdoe/jdoes-clone
             [ui]
             # name and email (local to this repository, optional), e.g.
             # username = Jane Doe <jdoe@example.com>
             """,
                 'global':
             b"""# example system-wide hg config (see 'hg help config' for more info)
             [ui]
             # uncomment to disable color in command output
             # (see 'hg help color' for details)
             # color = never
             # uncomment to disable command output pagination
             # (see 'hg help pager' for details)
             # paginate = never
             [extensions]
             # uncomment these lines to enable some popular extensions
             # (see 'hg help extensions' for more info)
             #
             # blackbox =
             # churn =
             """,
             }
             def _maybestrurl(maybebytes):
                 return pycompat.rapply(pycompat.strurl, maybebytes)
             def _maybebytesurl(maybestr):
                 return pycompat.rapply(pycompat.bytesurl, maybestr)
             class httppasswordmgrdbproxy(object):
                 """Delays loading urllib2 until it's needed."""
                 def __init__(self):
                     self._mgr = None
                 def _get_mgr(self):
                     if self._mgr is None:
                         self._mgr = urlreq.httppasswordmgrwithdefaultrealm()
                     return self._mgr
                 def add_password(self, realm, uris, user, passwd):
                     return self._get_mgr().add_password(
                         _maybestrurl(realm), _maybestrurl(uris),
                         _maybestrurl(user), _maybestrurl(passwd))
                 def find_user_password(self, realm, uri):
                     mgr = self._get_mgr()
                     return _maybebytesurl(mgr.find_user_password(_maybestrurl(realm),
                                                                  _maybestrurl(uri)))
             def _catchterm(*args):
                 raise error.SignalInterrupt
             # unique object used to detect no default value has been provided when
             # retrieving configuration value.
             _unset = object()
             # _reqexithandlers: callbacks run at the end of a request
             _reqexithandlers = []
             class ui(object):
                 def __init__(self, src=None):
                     """Create a fresh new ui object if no src given
                     Use uimod.ui.load() to create a ui which knows global and user configs.
                     In most cases, you should use ui.copy() to create a copy of an existing
                     ui object.
                     """
                     # _buffers: used for temporary capture of output
                     self._buffers = []
                     # 3-tuple describing how each buffer in the stack behaves.
                     # Values are (capture stderr, capture subprocesses, apply labels).
                     self._bufferstates = []
                     # When a buffer is active, defines whether we are expanding labels.
                     # This exists to prevent an extra list lookup.
                     self._bufferapplylabels = None
                     self.quiet = self.verbose = self.debugflag = self.tracebackflag = False
                     self._reportuntrusted = True
                     self._knownconfig = configitems.coreitems
                     self._ocfg = config.config() # overlay
                     self._tcfg = config.config() # trusted
                     self._ucfg = config.config() # untrusted
                     self._trustusers = set()
                     self._trustgroups = set()
                     self.callhooks = True
                     # Insecure server connections requested.
                     self.insecureconnections = False
                     # Blocked time
                     self.logblockedtimes = False
                     # color mode: see mercurial/color.py for possible value
                     self._colormode = None
                     self._terminfoparams = {}
                     self._styles = {}
                     self._uninterruptible = False
                     if src:
                         self.fout = src.fout
                         self.ferr = src.ferr
                         self.fin = src.fin
                         self._finoutredirected = src._finoutredirected
                         self.pageractive = src.pageractive
                         self._disablepager = src._disablepager
                         self._tweaked = src._tweaked
                         self._tcfg = src._tcfg.copy()
                         self._ucfg = src._ucfg.copy()
                         self._ocfg = src._ocfg.copy()
                         self._trustusers = src._trustusers.copy()
                         self._trustgroups = src._trustgroups.copy()
                         self.environ = src.environ
                         self.callhooks = src.callhooks
                         self.insecureconnections = src.insecureconnections
                         self._colormode = src._colormode
                         self._terminfoparams = src._terminfoparams.copy()
                         self._styles = src._styles.copy()
                         self.fixconfig()
                         self.httppasswordmgrdb = src.httppasswordmgrdb
                         self._blockedtimes = src._blockedtimes
                     else:
                         self.fout = procutil.stdout
                         self.ferr = procutil.stderr
                         self.fin = procutil.stdin
                         self._finoutredirected = False
                         self.pageractive = False
                         self._disablepager = False
                         self._tweaked = False
                         # shared read-only environment
                         self.environ = encoding.environ
                         self.httppasswordmgrdb = httppasswordmgrdbproxy()
                         self._blockedtimes = collections.defaultdict(int)
                     allowed = self.configlist('experimental', 'exportableenviron')
                     if '*' in allowed:
                         self._exportableenviron = self.environ
                     else:
                         self._exportableenviron = {}
                         for k in allowed:
                             if k in self.environ:
                                 self._exportableenviron[k] = self.environ[k]
                 @classmethod
                 def load(cls):
                     """Create a ui and load global and user configs"""
                     u = cls()
                     # we always trust global config files and environment variables
                     for t, f in rcutil.rccomponents():
                         if t == 'path':
                             u.readconfig(f, trust=True)
                         elif t == 'items':
                             sections = set()
                             for section, name, value, source in f:
                                 # do not set u._ocfg
                                 # XXX clean this up once immutable config object is a thing
                                 u._tcfg.set(section, name, value, source)
                                 u._ucfg.set(section, name, value, source)
                                 sections.add(section)
                             for section in sections:
                                 u.fixconfig(section=section)
                         else:
                             raise error.ProgrammingError('unknown rctype: %s' % t)
                     u._maybetweakdefaults()
                     return u
                 def _maybetweakdefaults(self):
                     if not self.configbool('ui', 'tweakdefaults'):
                         return
                     if self._tweaked or self.plain('tweakdefaults'):
                         return
                     # Note: it is SUPER IMPORTANT that you set self._tweaked to
                     # True *before* any calls to setconfig(), otherwise you'll get
                     # infinite recursion between setconfig and this method.
                     #
                     # TODO: We should extract an inner method in setconfig() to
                     # avoid this weirdness.
                     self._tweaked = True
                     tmpcfg = config.config()
                     tmpcfg.parse('<tweakdefaults>', tweakrc)
                     for section in tmpcfg:
                         for name, value in tmpcfg.items(section):
                             if not self.hasconfig(section, name):
                                 self.setconfig(section, name, value, "<tweakdefaults>")
                 def copy(self):
                     return self.__class__(self)
                 def resetstate(self):
                     """Clear internal state that shouldn't persist across commands"""
                     if self._progbar:
                         self._progbar.resetstate()  # reset last-print time of progress bar
                     self.httppasswordmgrdb = httppasswordmgrdbproxy()
                 @contextlib.contextmanager
                 def timeblockedsection(self, key):
                     # this is open-coded below - search for timeblockedsection to find them
                     starttime = util.timer()
                     try:
                         yield
                     finally:
                         self._blockedtimes[key + '_blocked'] += \
                             (util.timer() - starttime) * 1000
                 @contextlib.contextmanager
                 def uninterruptable(self):
                     """Mark an operation as unsafe.
                     Most operations on a repository are safe to interrupt, but a
                     few are risky (for example repair.strip). This context manager
                     lets you advise Mercurial that something risky is happening so
                     that control-C etc can be blocked if desired.
                     """
                     enabled = self.configbool('experimental', 'nointerrupt')
                     if (enabled and
                         self.configbool('experimental', 'nointerrupt-interactiveonly')):
                         enabled = self.interactive()
                     if self._uninterruptible or not enabled:
                         # if nointerrupt support is turned off, the process isn't
                         # interactive, or we're already in an uninterruptable
                         # block, do nothing.
                         yield
                         return
                     def warn():
                         self.warn(_("shutting down cleanly\n"))
                         self.warn(
                             _("press ^C again to terminate immediately (dangerous)\n"))
                         return True
                     with procutil.uninterruptable(warn):
                         try:
                             self._uninterruptible = True
                             yield
                         finally:
                             self._uninterruptible = False
                 def formatter(self, topic, opts):
                     return formatter.formatter(self, self, topic, opts)
                 def _trusted(self, fp, f):
                     st = util.fstat(fp)
                     if util.isowner(st):
                         return True
                     tusers, tgroups = self._trustusers, self._trustgroups
                     if '*' in tusers or '*' in tgroups:
                         return True
                     user = util.username(st.st_uid)
                     group = util.groupname(st.st_gid)
                     if user in tusers or group in tgroups or user == util.username():
                         return True
                     if self._reportuntrusted:
                         self.warn(_('not trusting file %s from untrusted '
                                     'user %s, group %s\n') % (f, user, group))
                     return False
                 def readconfig(self, filename, root=None, trust=False,
                                sections=None, remap=None):
                     try:
                         fp = open(filename, r'rb')
                     except IOError:
                         if not sections: # ignore unless we were looking for something
                             return
                         raise
                     cfg = config.config()
                     trusted = sections or trust or self._trusted(fp, filename)
                     try:
                         cfg.read(filename, fp, sections=sections, remap=remap)
                         fp.close()
                     except error.ConfigError as inst:
                         if trusted:
                             raise
                         self.warn(_("ignored: %s\n") % stringutil.forcebytestr(inst))
                     if self.plain():
                         for k in ('debug', 'fallbackencoding', 'quiet', 'slash',
                                   'logtemplate', 'statuscopies', 'style',
                                   'traceback', 'verbose'):
                             if k in cfg['ui']:
                                 del cfg['ui'][k]
                         for k, v in cfg.items('defaults'):
                             del cfg['defaults'][k]
                         for k, v in cfg.items('commands'):
                             del cfg['commands'][k]
                     # Don't remove aliases from the configuration if in the exceptionlist
                     if self.plain('alias'):
                         for k, v in cfg.items('alias'):
                             del cfg['alias'][k]
                     if self.plain('revsetalias'):
                         for k, v in cfg.items('revsetalias'):
                             del cfg['revsetalias'][k]
                     if self.plain('templatealias'):
                         for k, v in cfg.items('templatealias'):
                             del cfg['templatealias'][k]
                     if trusted:
                         self._tcfg.update(cfg)
                         self._tcfg.update(self._ocfg)
                     self._ucfg.update(cfg)
                     self._ucfg.update(self._ocfg)
                     if root is None:
                         root = os.path.expanduser('~')
                     self.fixconfig(root=root)
                 def fixconfig(self, root=None, section=None):
                     if section in (None, 'paths'):
                         # expand vars and ~
                         # translate paths relative to root (or home) into absolute paths
                         root = root or encoding.getcwd()
                         for c in self._tcfg, self._ucfg, self._ocfg:
                             for n, p in c.items('paths'):
                                 # Ignore sub-options.
                                 if ':' in n:
                                     continue
                                 if not p:
                                     continue
                                 if '%%' in p:
                                     s = self.configsource('paths', n) or 'none'
                                     self.warn(_("(deprecated '%%' in path %s=%s from %s)\n")
                                               % (n, p, s))
                                     p = p.replace('%%', '%')
                                 p = util.expandpath(p)
                                 if not util.hasscheme(p) and not os.path.isabs(p):
                                     p = os.path.normpath(os.path.join(root, p))
                                 c.set("paths", n, p)
                     if section in (None, 'ui'):
                         # update ui options
                         self.debugflag = self.configbool('ui', 'debug')
                         self.verbose = self.debugflag or self.configbool('ui', 'verbose')
                         self.quiet = not self.debugflag and self.configbool('ui', 'quiet')
                         if self.verbose and self.quiet:
                             self.quiet = self.verbose = False
                         self._reportuntrusted = self.debugflag or self.configbool("ui",
                             "report_untrusted")
                         self.tracebackflag = self.configbool('ui', 'traceback')
                         self.logblockedtimes = self.configbool('ui', 'logblockedtimes')
                     if section in (None, 'trusted'):
                         # update trust information
                         self._trustusers.update(self.configlist('trusted', 'users'))
                         self._trustgroups.update(self.configlist('trusted', 'groups'))
                 def backupconfig(self, section, item):
                     return (self._ocfg.backup(section, item),
                             self._tcfg.backup(section, item),
                             self._ucfg.backup(section, item),)
                 def restoreconfig(self, data):
                     self._ocfg.restore(data[0])
                     self._tcfg.restore(data[1])
                     self._ucfg.restore(data[2])
                 def setconfig(self, section, name, value, source=''):
                     for cfg in (self._ocfg, self._tcfg, self._ucfg):
                         cfg.set(section, name, value, source)
                     self.fixconfig(section=section)
                     self._maybetweakdefaults()
                 def _data(self, untrusted):
                     return untrusted and self._ucfg or self._tcfg
                 def configsource(self, section, name, untrusted=False):
                     return self._data(untrusted).source(section, name)
                 def config(self, section, name, default=_unset, untrusted=False):
                     """return the plain string version of a config"""
                     value = self._config(section, name, default=default,
                                          untrusted=untrusted)
                     if value is _unset:
                         return None
                     return value
                 def _config(self, section, name, default=_unset, untrusted=False):
                     value = itemdefault = default
                     item = self._knownconfig.get(section, {}).get(name)
                     alternates = [(section, name)]
                     if item is not None:
                         alternates.extend(item.alias)
                         if callable(item.default):
                             itemdefault = item.default()
                         else:
                             itemdefault = item.default
                     else:
                         msg = ("accessing unregistered config item: '%s.%s'")
                         msg %= (section, name)
                         self.develwarn(msg, 2, 'warn-config-unknown')
                     if default is _unset:
                         if item is None:
                             value = default
                         elif item.default is configitems.dynamicdefault:
                             value = None
                             msg = "config item requires an explicit default value: '%s.%s'"
                             msg %= (section, name)
                             self.develwarn(msg, 2, 'warn-config-default')
                         else:
                             value = itemdefault
                     elif (item is not None
                           and item.default is not configitems.dynamicdefault
                           and default != itemdefault):
                         msg = ("specifying a mismatched default value for a registered "
                                "config item: '%s.%s' '%s'")
                         msg %= (section, name, pycompat.bytestr(default))
                         self.develwarn(msg, 2, 'warn-config-default')
                     for s, n in alternates:
                         candidate = self._data(untrusted).get(s, n, None)
                         if candidate is not None:
                             value = candidate
                             section = s
                             name = n
                             break
                     if self.debugflag and not untrusted and self._reportuntrusted:
                         for s, n in alternates:
                             uvalue = self._ucfg.get(s, n)
                             if uvalue is not None and uvalue != value:
                                 self.debug("ignoring untrusted configuration option "
                                            "%s.%s = %s\n" % (s, n, uvalue))
                     return value
                 def configsuboptions(self, section, name, default=_unset, untrusted=False):
                     """Get a config option and all sub-options.
                     Some config options have sub-options that are declared with the
                     format "key:opt = value". This method is used to return the main
                     option and all its declared sub-options.
                     Returns a 2-tuple of ``(option, sub-options)``, where `sub-options``
                     is a dict of defined sub-options where keys and values are strings.
                     """
                     main = self.config(section, name, default, untrusted=untrusted)
                     data = self._data(untrusted)
                     sub = {}
                     prefix = '%s:' % name
                     for k, v in data.items(section):
                         if k.startswith(prefix):
                             sub[k[len(prefix):]] = v
                     if self.debugflag and not untrusted and self._reportuntrusted:
                         for k, v in sub.items():
                             uvalue = self._ucfg.get(section, '%s:%s' % (name, k))
                             if uvalue is not None and uvalue != v:
                                 self.debug('ignoring untrusted configuration option '
                                            '%s:%s.%s = %s\n' % (section, name, k, uvalue))
                     return main, sub
                 def configpath(self, section, name, default=_unset, untrusted=False):
                     'get a path config item, expanded relative to repo root or config file'
                     v = self.config(section, name, default, untrusted)
                     if v is None:
                         return None
                     if not os.path.isabs(v) or "://" not in v:
                         src = self.configsource(section, name, untrusted)
                         if ':' in src:
                             base = os.path.dirname(src.rsplit(':')[0])
                             v = os.path.join(base, os.path.expanduser(v))
                     return v
                 def configbool(self, section, name, default=_unset, untrusted=False):
                     """parse a configuration element as a boolean
                     >>> u = ui(); s = b'foo'
                     >>> u.setconfig(s, b'true', b'yes')
                     >>> u.configbool(s, b'true')
                     True
                     >>> u.setconfig(s, b'false', b'no')
                     >>> u.configbool(s, b'false')
                     False
                     >>> u.configbool(s, b'unknown')
                     False
                     >>> u.configbool(s, b'unknown', True)
                     True
                     >>> u.setconfig(s, b'invalid', b'somevalue')
                     >>> u.configbool(s, b'invalid')
                     Traceback (most recent call last):
                         ...
                     ConfigError: foo.invalid is not a boolean ('somevalue')
                     """
                     v = self._config(section, name, default, untrusted=untrusted)
                     if v is None:
                         return v
                     if v is _unset:
                         if default is _unset:
                             return False
                         return default
                     if isinstance(v, bool):
                         return v
                     b = stringutil.parsebool(v)
                     if b is None:
                         raise error.ConfigError(_("%s.%s is not a boolean ('%s')")
                                                 % (section, name, v))
                     return b
                 def configwith(self, convert, section, name, default=_unset,
                                desc=None, untrusted=False):
                     """parse a configuration element with a conversion function
                     >>> u = ui(); s = b'foo'
                     >>> u.setconfig(s, b'float1', b'42')
                     >>> u.configwith(float, s, b'float1')
 .0
                     >>> u.setconfig(s, b'float2', b'-4.25')
                     >>> u.configwith(float, s, b'float2')
                     -4.25
                     >>> u.configwith(float, s, b'unknown', 7)
 .0
                     >>> u.setconfig(s, b'invalid', b'somevalue')
                     >>> u.configwith(float, s, b'invalid')
                     Traceback (most recent call last):
                         ...
                     ConfigError: foo.invalid is not a valid float ('somevalue')
                     >>> u.configwith(float, s, b'invalid', desc=b'womble')
                     Traceback (most recent call last):
                         ...
                     ConfigError: foo.invalid is not a valid womble ('somevalue')
                     """
                     v = self.config(section, name, default, untrusted)
                     if v is None:
                         return v # do not attempt to convert None
                     try:
                         return convert(v)
                     except (ValueError, error.ParseError):
                         if desc is None:
                             desc = pycompat.sysbytes(convert.__name__)
                         raise error.ConfigError(_("%s.%s is not a valid %s ('%s')")
                                                 % (section, name, desc, v))
                 def configint(self, section, name, default=_unset, untrusted=False):
                     """parse a configuration element as an integer
                     >>> u = ui(); s = b'foo'
                     >>> u.setconfig(s, b'int1', b'42')
                     >>> u.configint(s, b'int1')
                     >>> u.setconfig(s, b'int2', b'-42')
                     >>> u.configint(s, b'int2')
                     -42
                     >>> u.configint(s, b'unknown', 7)
                     >>> u.setconfig(s, b'invalid', b'somevalue')
                     >>> u.configint(s, b'invalid')
                     Traceback (most recent call last):
                         ...
                     ConfigError: foo.invalid is not a valid integer ('somevalue')
                     """
                     return self.configwith(int, section, name, default, 'integer',
                                            untrusted)
                 def configbytes(self, section, name, default=_unset, untrusted=False):
                     """parse a configuration element as a quantity in bytes
                     Units can be specified as b (bytes), k or kb (kilobytes), m or
                     mb (megabytes), g or gb (gigabytes).
                     >>> u = ui(); s = b'foo'
                     >>> u.setconfig(s, b'val1', b'42')
                     >>> u.configbytes(s, b'val1')
                     >>> u.setconfig(s, b'val2', b'42.5 kb')
                     >>> u.configbytes(s, b'val2')
                     >>> u.configbytes(s, b'unknown', b'7 MB')
                     7340032
                     >>> u.setconfig(s, b'invalid', b'somevalue')
                     >>> u.configbytes(s, b'invalid')
                     Traceback (most recent call last):
                         ...
                     ConfigError: foo.invalid is not a byte quantity ('somevalue')
                     """
                     value = self._config(section, name, default, untrusted)
                     if value is _unset:
                         if default is _unset:
                             default = 0
                         value = default
                     if not isinstance(value, bytes):
                         return value
                     try:
                         return util.sizetoint(value)
                     except error.ParseError:
                         raise error.ConfigError(_("%s.%s is not a byte quantity ('%s')")
                                                 % (section, name, value))
                 def configlist(self, section, name, default=_unset, untrusted=False):
                     """parse a configuration element as a list of comma/space separated
                     strings
                     >>> u = ui(); s = b'foo'
                     >>> u.setconfig(s, b'list1', b'this,is "a small" ,test')
                     >>> u.configlist(s, b'list1')
                     ['this', 'is', 'a small', 'test']
                     >>> u.setconfig(s, b'list2', b'this, is "a small" , test ')
                     >>> u.configlist(s, b'list2')
                     ['this', 'is', 'a small', 'test']
                     """
                     # default is not always a list
                     v = self.configwith(config.parselist, section, name, default,
                                            'list', untrusted)
                     if isinstance(v, bytes):
                         return config.parselist(v)
                     elif v is None:
                         return []
                     return v
                 def configdate(self, section, name, default=_unset, untrusted=False):
                     """parse a configuration element as a tuple of ints
                     >>> u = ui(); s = b'foo'
                     >>> u.setconfig(s, b'date', b'0 0')
                     >>> u.configdate(s, b'date')
                     (0, 0)
                     """
                     if self.config(section, name, default, untrusted):
                         return self.configwith(dateutil.parsedate, section, name, default,
                                                'date', untrusted)
                     if default is _unset:
                         return None
                     return default
                 def hasconfig(self, section, name, untrusted=False):
                     return self._data(untrusted).hasitem(section, name)
                 def has_section(self, section, untrusted=False):
                     '''tell whether section exists in config.'''
                     return section in self._data(untrusted)
                 def configitems(self, section, untrusted=False, ignoresub=False):
                     items = self._data(untrusted).items(section)
                     if ignoresub:
                         items = [i for i in items if ':' not in i[0]]
                     if self.debugflag and not untrusted and self._reportuntrusted:
                         for k, v in self._ucfg.items(section):
                             if self._tcfg.get(section, k) != v:
                                 self.debug("ignoring untrusted configuration option "
                                            "%s.%s = %s\n" % (section, k, v))
                     return items
                 def walkconfig(self, untrusted=False):
                     cfg = self._data(untrusted)
                     for section in cfg.sections():
                         for name, value in self.configitems(section, untrusted):
                             yield section, name, value
                 def plain(self, feature=None):
                     '''is plain mode active?
                     Plain mode means that all configuration variables which affect
                     the behavior and output of Mercurial should be
                     ignored. Additionally, the output should be stable,
                     reproducible and suitable for use in scripts or applications.
                     The only way to trigger plain mode is by setting either the
                     `HGPLAIN' or `HGPLAINEXCEPT' environment variables.
                     The return value can either be
                     - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
                     - False if feature is disabled by default and not included in HGPLAIN
                     - True otherwise
                     '''
                     if ('HGPLAIN' not in encoding.environ and
                             'HGPLAINEXCEPT' not in encoding.environ):
                         return False
                     exceptions = encoding.environ.get('HGPLAINEXCEPT',
                             '').strip().split(',')
                     # TODO: add support for HGPLAIN=+feature,-feature syntax
                     if '+strictflags' not in encoding.environ.get('HGPLAIN', '').split(','):
                         exceptions.append('strictflags')
                     if feature and exceptions:
                         return feature not in exceptions
                     return True
                 def username(self, acceptempty=False):
                     """Return default username to be used in commits.
                     Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
                     and stop searching if one of these is set.
                     If not found and acceptempty is True, returns None.
                     If not found and ui.askusername is True, ask the user, else use
                     ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
                     If no username could be found, raise an Abort error.
                     """
                     user = encoding.environ.get("HGUSER")
                     if user is None:
                         user = self.config("ui", "username")
                         if user is not None:
                             user = os.path.expandvars(user)
                     if user is None:
                         user = encoding.environ.get("EMAIL")
                     if user is None and acceptempty:
                         return user
                     if user is None and self.configbool("ui", "askusername"):
                         user = self.prompt(_("enter a commit username:"), default=None)
                     if user is None and not self.interactive():
                         try:
                             user = '%s@%s' % (procutil.getuser(),
                                               encoding.strtolocal(socket.getfqdn()))
                             self.warn(_("no username found, using '%s' instead\n") % user)
                         except KeyError:
                             pass
                     if not user:
                         raise error.Abort(_('no username supplied'),
                                          hint=_("use 'hg config --edit' "
                                                 'to set your username'))
                     if "\n" in user:
                         raise error.Abort(_("username %r contains a newline\n")
                                           % pycompat.bytestr(user))
                     return user
                 def shortuser(self, user):
                     """Return a short representation of a user name or email address."""
                     if not self.verbose:
                         user = stringutil.shortuser(user)
                     return user
                 def expandpath(self, loc, default=None):
                     """Return repository location relative to cwd or from [paths]"""
                     try:
                         p = self.paths.getpath(loc)
                         if p:
                             return p.rawloc
                     except error.RepoError:
                         pass
                     if default:
                         try:
                             p = self.paths.getpath(default)
                             if p:
                                 return p.rawloc
                         except error.RepoError:
                             pass
                     return loc
                 @util.propertycache
                 def paths(self):
                     return paths(self)
                 def pushbuffer(self, error=False, subproc=False, labeled=False):
                     """install a buffer to capture standard output of the ui object
                     If error is True, the error output will be captured too.
                     If subproc is True, output from subprocesses (typically hooks) will be
                     captured too.
                     If labeled is True, any labels associated with buffered
                     output will be handled. By default, this has no effect
                     on the output returned, but extensions and GUI tools may
                     handle this argument and returned styled output. If output
                     is being buffered so it can be captured and parsed or
                     processed, labeled should not be set to True.
                     """
                     self._buffers.append([])
                     self._bufferstates.append((error, subproc, labeled))
                     self._bufferapplylabels = labeled
                 def popbuffer(self):
                     '''pop the last buffer and return the buffered output'''
                     self._bufferstates.pop()
                     if self._bufferstates:
                         self._bufferapplylabels = self._bufferstates[-1][2]
                     else:
                         self._bufferapplylabels = None
                     return "".join(self._buffers.pop())
                 def canwritewithoutlabels(self):
                     '''check if write skips the label'''
                     if self._buffers and not self._bufferapplylabels:
                         return True
                     return self._colormode is None
                 def canbatchlabeledwrites(self):
                     '''check if write calls with labels are batchable'''
                     # Windows color printing is special, see ``write``.
                     return self._colormode != 'win32'
                 def write(self, *args, **opts):
                     '''write args to output
                     By default, this method simply writes to the buffer or stdout.
                     Color mode can be set on the UI class to have the output decorated
                     with color modifier before being written to stdout.
                     The color used is controlled by an optional keyword argument, "label".
                     This should be a string containing label names separated by space.
                     Label names take the form of "topic.type". For example, ui.debug()
                     issues a label of "ui.debug".
                     When labeling output for a specific command, a label of
                     "cmdname.type" is recommended. For example, status issues
                     a label of "status.modified" for modified files.
                     '''
                     if self._buffers:
                         if self._bufferapplylabels:
                             label = opts.get(r'label', '')
                             self._buffers[-1].extend(self.label(a, label) for a in args)
                         else:
                             self._buffers[-1].extend(args)
                     else:
                         self._writenobuf(*args, **opts)
                 def _writenobuf(self, *args, **opts):
                     if self._colormode == 'win32':
                         # windows color printing is its own can of crab, defer to
                         # the color module and that is it.
                         color.win32print(self, self._write, *args, **opts)
                     else:
                         msgs = args
                         if self._colormode is not None:
                             label = opts.get(r'label', '')
                             msgs = [self.label(a, label) for a in args]
                         self._write(*msgs, **opts)
                 def _write(self, *msgs, **opts):
                     self._progclear()
                     # opencode timeblockedsection because this is a critical path
                     starttime = util.timer()
                     try:
                         self.fout.write(''.join(msgs))
                     except IOError as err:
                         raise error.StdioError(err)
                     finally:
                         self._blockedtimes['stdio_blocked'] += \
                             (util.timer() - starttime) * 1000
                 def write_err(self, *args, **opts):
                     self._progclear()
                     if self._bufferstates and self._bufferstates[-1][0]:
                         self.write(*args, **opts)
                     elif self._colormode == 'win32':
                         # windows color printing is its own can of crab, defer to
                         # the color module and that is it.
                         color.win32print(self, self._write_err, *args, **opts)
                     else:
                         msgs = args
                         if self._colormode is not None:
                             label = opts.get(r'label', '')
                             msgs = [self.label(a, label) for a in args]
                         self._write_err(*msgs, **opts)
                 def _write_err(self, *msgs, **opts):
                     try:
                         with self.timeblockedsection('stdio'):
                             if not getattr(self.fout, 'closed', False):
                                 self.fout.flush()
                             for a in msgs:
                                 self.ferr.write(a)
                             # stderr may be buffered under win32 when redirected to files,
                             # including stdout.
                             if not getattr(self.ferr, 'closed', False):
                                 self.ferr.flush()
                     except IOError as inst:
                         if inst.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                             raise error.StdioError(inst)
                 def flush(self):
                     # opencode timeblockedsection because this is a critical path
                     starttime = util.timer()
                     try:
                         try:
                             self.fout.flush()
                         except IOError as err:
                             if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                                 raise error.StdioError(err)
                         finally:
                             try:
                                 self.ferr.flush()
                             except IOError as err:
                                 if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                                     raise error.StdioError(err)
                     finally:
                         self._blockedtimes['stdio_blocked'] += \
                             (util.timer() - starttime) * 1000
                 def _isatty(self, fh):
                     if self.configbool('ui', 'nontty'):
                         return False
                     return procutil.isatty(fh)
                 def disablepager(self):
                     self._disablepager = True
                 def pager(self, command):
                     """Start a pager for subsequent command output.
                     Commands which produce a long stream of output should call
                     this function to activate the user's preferred pagination
                     mechanism (which may be no pager). Calling this function
                     precludes any future use of interactive functionality, such as
                     prompting the user or activating curses.
                     Args:
                       command: The full, non-aliased name of the command. That is, "log"
                                not "history, "summary" not "summ", etc.
                     """
                     if (self._disablepager
                         or self.pageractive):
                         # how pager should do is already determined
                         return
                     if not command.startswith('internal-always-') and (
                         # explicit --pager=on (= 'internal-always-' prefix) should
                         # take precedence over disabling factors below
                         command in self.configlist('pager', 'ignore')
                         or not self.configbool('ui', 'paginate')
                         or not self.configbool('pager', 'attend-' + command, True)
                         or encoding.environ.get('TERM') == 'dumb'
                         # TODO: if we want to allow HGPLAINEXCEPT=pager,
                         # formatted() will need some adjustment.
                         or not self.formatted()
                         or self.plain()
                         or self._buffers
                         # TODO: expose debugger-enabled on the UI object
                         or '--debugger' in pycompat.sysargv):
                         # We only want to paginate if the ui appears to be
                         # interactive, the user didn't say HGPLAIN or
                         # HGPLAINEXCEPT=pager, and the user didn't specify --debug.
                         return
                     pagercmd = self.config('pager', 'pager', rcutil.fallbackpager)
                     if not pagercmd:
                         return
                     pagerenv = {}
                     for name, value in rcutil.defaultpagerenv().items():
                         if name not in encoding.environ:
                             pagerenv[name] = value
-                    self.debug('starting pager for command %r\n' % command)
+                    self.debug('starting pager for command %s\n' %
+                               stringutil.pprint(command))
                     self.flush()
                     wasformatted = self.formatted()
                     if util.safehasattr(signal, "SIGPIPE"):
                         signal.signal(signal.SIGPIPE, _catchterm)
                     if self._runpager(pagercmd, pagerenv):
                         self.pageractive = True
                         # Preserve the formatted-ness of the UI. This is important
                         # because we mess with stdout, which might confuse
                         # auto-detection of things being formatted.
                         self.setconfig('ui', 'formatted', wasformatted, 'pager')
                         self.setconfig('ui', 'interactive', False, 'pager')
                         # If pagermode differs from color.mode, reconfigure color now that
                         # pageractive is set.
                         cm = self._colormode
                         if cm != self.config('color', 'pagermode', cm):
                             color.setup(self)
                     else:
                         # If the pager can't be spawned in dispatch when --pager=on is
                         # given, don't try again when the command runs, to avoid a duplicate
                         # warning about a missing pager command.
                         self.disablepager()
                 def _runpager(self, command, env=None):
                     """Actually start the pager and set up file descriptors.
                     This is separate in part so that extensions (like chg) can
                     override how a pager is invoked.
                     """
                     if command == 'cat':
                         # Save ourselves some work.
                         return False
                     # If the command doesn't contain any of these characters, we
                     # assume it's a binary and exec it directly. This means for
                     # simple pager command configurations, we can degrade
                     # gracefully and tell the user about their broken pager.
                     shell = any(c in command for c in "|&;<>()$`\\\"' \t\n*?[#~=%")
                     if pycompat.iswindows and not shell:
                         # Window's built-in `more` cannot be invoked with shell=False, but
                         # its `more.com` can.  Hide this implementation detail from the
                         # user so we can also get sane bad PAGER behavior.  MSYS has
                         # `more.exe`, so do a cmd.exe style resolution of the executable to
                         # determine which one to use.
                         fullcmd = procutil.findexe(command)
                         if not fullcmd:
                             self.warn(_("missing pager command '%s', skipping pager\n")
                                       % command)
                             return False
                         command = fullcmd
                     try:
                         pager = subprocess.Popen(
                             procutil.tonativestr(command), shell=shell, bufsize=-1,
                             close_fds=procutil.closefds, stdin=subprocess.PIPE,
                             stdout=procutil.stdout, stderr=procutil.stderr,
                             env=procutil.tonativeenv(procutil.shellenviron(env)))
                     except OSError as e:
                         if e.errno == errno.ENOENT and not shell:
                             self.warn(_("missing pager command '%s', skipping pager\n")
                                       % command)
                             return False
                         raise
                     # back up original file descriptors
                     stdoutfd = os.dup(procutil.stdout.fileno())
                     stderrfd = os.dup(procutil.stderr.fileno())
                     os.dup2(pager.stdin.fileno(), procutil.stdout.fileno())
                     if self._isatty(procutil.stderr):
                         os.dup2(pager.stdin.fileno(), procutil.stderr.fileno())
                     @self.atexit
                     def killpager():
                         if util.safehasattr(signal, "SIGINT"):
                             signal.signal(signal.SIGINT, signal.SIG_IGN)
                         # restore original fds, closing pager.stdin copies in the process
                         os.dup2(stdoutfd, procutil.stdout.fileno())
                         os.dup2(stderrfd, procutil.stderr.fileno())
                         pager.stdin.close()
                         pager.wait()
                     return True
                 @property
                 def _exithandlers(self):
                     return _reqexithandlers
                 def atexit(self, func, *args, **kwargs):
                     '''register a function to run after dispatching a request
                     Handlers do not stay registered across request boundaries.'''
                     self._exithandlers.append((func, args, kwargs))
                     return func
                 def interface(self, feature):
                     """what interface to use for interactive console features?
                     The interface is controlled by the value of `ui.interface` but also by
                     the value of feature-specific configuration. For example:
                     ui.interface.histedit = text
                     ui.interface.chunkselector = curses
                     Here the features are "histedit" and "chunkselector".
                     The configuration above means that the default interfaces for commands
                     is curses, the interface for histedit is text and the interface for
                     selecting chunk is crecord (the best curses interface available).
                     Consider the following example:
                     ui.interface = curses
                     ui.interface.histedit = text
                     Then histedit will use the text interface and chunkselector will use
                     the default curses interface (crecord at the moment).
                     """
                     alldefaults = frozenset(["text", "curses"])
                     featureinterfaces = {
                         "chunkselector": [
                             "text",
                             "curses",
                         ]
                     }
                     # Feature-specific interface
                     if feature not in featureinterfaces.keys():
                         # Programming error, not user error
                         raise ValueError("Unknown feature requested %s" % feature)
                     availableinterfaces = frozenset(featureinterfaces[feature])
                     if alldefaults > availableinterfaces:
                         # Programming error, not user error. We need a use case to
                         # define the right thing to do here.
                         raise ValueError(
                             "Feature %s does not handle all default interfaces" %
                             feature)
                     if self.plain() or encoding.environ.get('TERM') == 'dumb':
                         return "text"
                     # Default interface for all the features
                     defaultinterface = "text"
                     i = self.config("ui", "interface")
                     if i in alldefaults:
                         defaultinterface = i
                     choseninterface = defaultinterface
                     f = self.config("ui", "interface.%s" % feature)
                     if f in availableinterfaces:
                         choseninterface = f
                     if i is not None and defaultinterface != i:
                         if f is not None:
                             self.warn(_("invalid value for ui.interface: %s\n") %
                                       (i,))
                         else:
                             self.warn(_("invalid value for ui.interface: %s (using %s)\n") %
                                      (i, choseninterface))
                     if f is not None and choseninterface != f:
                         self.warn(_("invalid value for ui.interface.%s: %s (using %s)\n") %
                                   (feature, f, choseninterface))
                     return choseninterface
                 def interactive(self):
                     '''is interactive input allowed?
                     An interactive session is a session where input can be reasonably read
                     from `sys.stdin'. If this function returns false, any attempt to read
                     from stdin should fail with an error, unless a sensible default has been
                     specified.
                     Interactiveness is triggered by the value of the `ui.interactive'
                     configuration variable or - if it is unset - when `sys.stdin' points
                     to a terminal device.
                     This function refers to input only; for output, see `ui.formatted()'.
                     '''
                     i = self.configbool("ui", "interactive")
                     if i is None:
                         # some environments replace stdin without implementing isatty
                         # usually those are non-interactive
                         return self._isatty(self.fin)
                     return i
                 def termwidth(self):
                     '''how wide is the terminal in columns?
                     '''
                     if 'COLUMNS' in encoding.environ:
                         try:
                             return int(encoding.environ['COLUMNS'])
                         except ValueError:
                             pass
                     return scmutil.termsize(self)[0]
                 def formatted(self):
                     '''should formatted output be used?
                     It is often desirable to format the output to suite the output medium.
                     Examples of this are truncating long lines or colorizing messages.
                     However, this is not often not desirable when piping output into other
                     utilities, e.g. `grep'.
                     Formatted output is triggered by the value of the `ui.formatted'
                     configuration variable or - if it is unset - when `sys.stdout' points
                     to a terminal device. Please note that `ui.formatted' should be
                     considered an implementation detail; it is not intended for use outside
                     Mercurial or its extensions.
                     This function refers to output only; for input, see `ui.interactive()'.
                     This function always returns false when in plain mode, see `ui.plain()'.
                     '''
                     if self.plain():
                         return False
                     i = self.configbool("ui", "formatted")
                     if i is None:
                         # some environments replace stdout without implementing isatty
                         # usually those are non-interactive
                         return self._isatty(self.fout)
                     return i
                 def _readline(self):
                     # Replacing stdin/stdout temporarily is a hard problem on Python 3
                     # because they have to be text streams with *no buffering*. Instead,
                     # we use rawinput() only if call_readline() will be invoked by
                     # PyOS_Readline(), so no I/O will be made at Python layer.
                     usereadline = (self._isatty(self.fin) and self._isatty(self.fout)
                                    and procutil.isstdin(self.fin)
                                    and procutil.isstdout(self.fout))
                     if usereadline:
                         try:
                             # magically add command line editing support, where
                             # available
                             import readline
                             # force demandimport to really load the module
                             readline.read_history_file
                             # windows sometimes raises something other than ImportError
                         except Exception:
                             usereadline = False
                     # prompt ' ' must exist; otherwise readline may delete entire line
                     # - http://bugs.python.org/issue12833
                     with self.timeblockedsection('stdio'):
                         if usereadline:
                             line = encoding.strtolocal(pycompat.rawinput(r' '))
                             # When stdin is in binary mode on Windows, it can cause
                             # raw_input() to emit an extra trailing carriage return
                             if pycompat.oslinesep == b'\r\n' and line.endswith(b'\r'):
                                 line = line[:-1]
                         else:
                             self.fout.write(b' ')
                             self.fout.flush()
                             line = self.fin.readline()
                             if not line:
                                 raise EOFError
                             line = line.rstrip(pycompat.oslinesep)
                     return line
                 def prompt(self, msg, default="y"):
                     """Prompt user with msg, read response.
                     If ui is not interactive, the default is returned.
                     """
                     if not self.interactive():
                         self.write(msg, ' ', default or '', "\n")
                         return default
                     self._writenobuf(msg, label='ui.prompt')
                     self.flush()
                     try:
                         r = self._readline()
                         if not r:
                             r = default
                         if self.configbool('ui', 'promptecho'):
                             self.write(r, "\n")
                         return r
                     except EOFError:
                         raise error.ResponseExpected()
                 @staticmethod
                 def extractchoices(prompt):
                     """Extract prompt message and list of choices from specified prompt.
                     This returns tuple "(message, choices)", and "choices" is the
                     list of tuple "(response character, text without &)".
                     >>> ui.extractchoices(b"awake? $$ &Yes $$ &No")
                     ('awake? ', [('y', 'Yes'), ('n', 'No')])
                     >>> ui.extractchoices(b"line\\nbreak? $$ &Yes $$ &No")
                     ('line\\nbreak? ', [('y', 'Yes'), ('n', 'No')])
                     >>> ui.extractchoices(b"want lots of $$money$$?$$Ye&s$$N&o")
                     ('want lots of $$money$$?', [('s', 'Yes'), ('o', 'No')])
                     """
                     # Sadly, the prompt string may have been built with a filename
                     # containing "$$" so let's try to find the first valid-looking
                     # prompt to start parsing. Sadly, we also can't rely on
                     # choices containing spaces, ASCII, or basically anything
                     # except an ampersand followed by a character.
                     m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt)
                     msg = m.group(1)
                     choices = [p.strip(' ') for p in m.group(2).split('$$')]
                     def choicetuple(s):
                         ampidx = s.index('&')
                         return s[ampidx + 1:ampidx + 2].lower(), s.replace('&', '', 1)
                     return (msg, [choicetuple(s) for s in choices])
                 def promptchoice(self, prompt, default=0):
                     """Prompt user with a message, read response, and ensure it matches
                     one of the provided choices. The prompt is formatted as follows:
                        "would you like fries with that (Yn)? $$ &Yes $$ &No"
                     The index of the choice is returned. Responses are case
                     insensitive. If ui is not interactive, the default is
                     returned.
                     """
                     msg, choices = self.extractchoices(prompt)
                     resps = [r for r, t in choices]
                     while True:
                         r = self.prompt(msg, resps[default])
                         if r.lower() in resps:
                             return resps.index(r.lower())
                         self.write(_("unrecognized response\n"))
                 def getpass(self, prompt=None, default=None):
                     if not self.interactive():
                         return default
                     try:
                         self.write_err(self.label(prompt or _('password: '), 'ui.prompt'))
                         # disable getpass() only if explicitly specified. it's still valid
                         # to interact with tty even if fin is not a tty.
                         with self.timeblockedsection('stdio'):
                             if self.configbool('ui', 'nontty'):
                                 l = self.fin.readline()
                                 if not l:
                                     raise EOFError
                                 return l.rstrip('\n')
                             else:
                                 return getpass.getpass('')
                     except EOFError:
                         raise error.ResponseExpected()
                 def status(self, *msg, **opts):
                     '''write status message to output (if ui.quiet is False)
                     This adds an output label of "ui.status".
                     '''
                     if not self.quiet:
                         opts[r'label'] = opts.get(r'label', '') + ' ui.status'
                         self.write(*msg, **opts)
                 def warn(self, *msg, **opts):
                     '''write warning message to output (stderr)
                     This adds an output label of "ui.warning".
                     '''
                     opts[r'label'] = opts.get(r'label', '') + ' ui.warning'
                     self.write_err(*msg, **opts)
                 def error(self, *msg, **opts):
                     '''write error message to output (stderr)
                     This adds an output label of "ui.error".
                     '''
                     opts[r'label'] = opts.get(r'label', '') + ' ui.error'
                     self.write_err(*msg, **opts)
                 def note(self, *msg, **opts):
                     '''write note to output (if ui.verbose is True)
                     This adds an output label of "ui.note".
                     '''
                     if self.verbose:
                         opts[r'label'] = opts.get(r'label', '') + ' ui.note'
                         self.write(*msg, **opts)
                 def debug(self, *msg, **opts):
                     '''write debug message to output (if ui.debugflag is True)
                     This adds an output label of "ui.debug".
                     '''
                     if self.debugflag:
                         opts[r'label'] = opts.get(r'label', '') + ' ui.debug'
                         self.write(*msg, **opts)
                 def edit(self, text, user, extra=None, editform=None, pending=None,
                          repopath=None, action=None):
                     if action is None:
                         self.develwarn('action is None but will soon be a required '
                                        'parameter to ui.edit()')
                     extra_defaults = {
                         'prefix': 'editor',
                         'suffix': '.txt',
                     }
                     if extra is not None:
                         if extra.get('suffix') is not None:
                             self.develwarn('extra.suffix is not None but will soon be '
                                            'ignored by ui.edit()')
                         extra_defaults.update(extra)
                     extra = extra_defaults
                     if action == 'diff':
                         suffix = '.diff'
                     elif action:
                         suffix = '.%s.hg.txt' % action
                     else:
                         suffix = extra['suffix']
                     rdir = None
                     if self.configbool('experimental', 'editortmpinhg'):
                         rdir = repopath
                     (fd, name) = pycompat.mkstemp(prefix='hg-' + extra['prefix'] + '-',
                                                   suffix=suffix,
                                                   dir=rdir)
                     try:
                         f = os.fdopen(fd, r'wb')
                         f.write(util.tonativeeol(text))
                         f.close()
                         environ = {'HGUSER': user}
                         if 'transplant_source' in extra:
                             environ.update({'HGREVISION': hex(extra['transplant_source'])})
                         for label in ('intermediate-source', 'source', 'rebase_source'):
                             if label in extra:
                                 environ.update({'HGREVISION': extra[label]})
                                 break
                         if editform:
                             environ.update({'HGEDITFORM': editform})
                         if pending:
                             environ.update({'HG_PENDING': pending})
                         editor = self.geteditor()
                         self.system("%s \"%s\"" % (editor, name),
                                     environ=environ,
                                     onerr=error.Abort, errprefix=_("edit failed"),
                                     blockedtag='editor')
                         f = open(name, r'rb')
                         t = util.fromnativeeol(f.read())
                         f.close()
                     finally:
                         os.unlink(name)
                     return t
                 def system(self, cmd, environ=None, cwd=None, onerr=None, errprefix=None,
                            blockedtag=None):
                     '''execute shell command with appropriate output stream. command
                     output will be redirected if fout is not stdout.
                     if command fails and onerr is None, return status, else raise onerr
                     object as exception.
                     '''
                     if blockedtag is None:
                         # Long cmds tend to be because of an absolute path on cmd. Keep
                         # the tail end instead
                         cmdsuffix = cmd.translate(None, _keepalnum)[-85:]
                         blockedtag = 'unknown_system_' + cmdsuffix
                     out = self.fout
                     if any(s[1] for s in self._bufferstates):
                         out = self
                     with self.timeblockedsection(blockedtag):
                         rc = self._runsystem(cmd, environ=environ, cwd=cwd, out=out)
                     if rc and onerr:
                         errmsg = '%s %s' % (os.path.basename(cmd.split(None, 1)[0]),
                                             procutil.explainexit(rc))
                         if errprefix:
                             errmsg = '%s: %s' % (errprefix, errmsg)
                         raise onerr(errmsg)
                     return rc
                 def _runsystem(self, cmd, environ, cwd, out):
                     """actually execute the given shell command (can be overridden by
                     extensions like chg)"""
                     return procutil.system(cmd, environ=environ, cwd=cwd, out=out)
                 def traceback(self, exc=None, force=False):
                     '''print exception traceback if traceback printing enabled or forced.
                     only to call in exception handler. returns true if traceback
                     printed.'''
                     if self.tracebackflag or force:
                         if exc is None:
                             exc = sys.exc_info()
                         cause = getattr(exc[1], 'cause', None)
                         if cause is not None:
                             causetb = traceback.format_tb(cause[2])
                             exctb = traceback.format_tb(exc[2])
                             exconly = traceback.format_exception_only(cause[0], cause[1])
                             # exclude frame where 'exc' was chained and rethrown from exctb
                             self.write_err('Traceback (most recent call last):\n',
                                            ''.join(exctb[:-1]),
                                            ''.join(causetb),
                                            ''.join(exconly))
                         else:
                             output = traceback.format_exception(exc[0], exc[1], exc[2])
                             self.write_err(encoding.strtolocal(r''.join(output)))
                     return self.tracebackflag or force
                 def geteditor(self):
                     '''return editor to use'''
                     if pycompat.sysplatform == 'plan9':
                         # vi is the MIPS instruction simulator on Plan 9. We
                         # instead default to E to plumb commit messages to
                         # avoid confusion.
                         editor = 'E'
                     else:
                         editor = 'vi'
                     return (encoding.environ.get("HGEDITOR") or
                             self.config("ui", "editor", editor))
                 @util.propertycache
                 def _progbar(self):
                     """setup the progbar singleton to the ui object"""
                     if (self.quiet or self.debugflag
                             or self.configbool('progress', 'disable')
                             or not progress.shouldprint(self)):
                         return None
                     return getprogbar(self)
                 def _progclear(self):
                     """clear progress bar output if any. use it before any output"""
                     if not haveprogbar(): # nothing loaded yet
                         return
                     if self._progbar is not None and self._progbar.printed:
                         self._progbar.clear()
                 def progress(self, topic, pos, item="", unit="", total=None):
                     '''show a progress message
                     By default a textual progress bar will be displayed if an operation
                     takes too long. 'topic' is the current operation, 'item' is a
                     non-numeric marker of the current position (i.e. the currently
                     in-process file), 'pos' is the current numeric position (i.e.
                     revision, bytes, etc.), unit is a corresponding unit label,
                     and total is the highest expected pos.
                     Multiple nested topics may be active at a time.
                     All topics should be marked closed by setting pos to None at
                     termination.
                     '''
                     if self._progbar is not None:
                         self._progbar.progress(topic, pos, item=item, unit=unit,
                                                total=total)
                     if pos is None or not self.configbool('progress', 'debug'):
                         return
                     if unit:
                         unit = ' ' + unit
                     if item:
                         item = ' ' + item
                     if total:
                         pct = 100.0 * pos / total
                         self.debug('%s:%s %d/%d%s (%4.2f%%)\n'
                                  % (topic, item, pos, total, unit, pct))
                     else:
                         self.debug('%s:%s %d%s\n' % (topic, item, pos, unit))
                 def makeprogress(self, topic, unit="", total=None):
                     '''exists only so low-level modules won't need to import scmutil'''
                     return scmutil.progress(self, topic, unit, total)
                 def log(self, service, *msg, **opts):
                     '''hook for logging facility extensions
                     service should be a readily-identifiable subsystem, which will
                     allow filtering.
                     *msg should be a newline-terminated format string to log, and
                     then any values to %-format into that format string.
                     **opts currently has no defined meanings.
                     '''
                 def label(self, msg, label):
                     '''style msg based on supplied label
                     If some color mode is enabled, this will add the necessary control
                     characters to apply such color. In addition, 'debug' color mode adds
                     markup showing which label affects a piece of text.
                     ui.write(s, 'label') is equivalent to
                     ui.write(ui.label(s, 'label')).
                     '''
                     if self._colormode is not None:
                         return color.colorlabel(self, msg, label)
                     return msg
                 def develwarn(self, msg, stacklevel=1, config=None):
                     """issue a developer warning message
                     Use 'stacklevel' to report the offender some layers further up in the
                     stack.
                     """
                     if not self.configbool('devel', 'all-warnings'):
                         if config is None or not self.configbool('devel', config):
                             return
                     msg = 'devel-warn: ' + msg
                     stacklevel += 1 # get in develwarn
                     if self.tracebackflag:
                         util.debugstacktrace(msg, stacklevel, self.ferr, self.fout)
                         self.log('develwarn', '%s at:\n%s' %
                                  (msg, ''.join(util.getstackframes(stacklevel))))
                     else:
                         curframe = inspect.currentframe()
                         calframe = inspect.getouterframes(curframe, 2)
                         fname, lineno, fmsg = calframe[stacklevel][1:4]
                         fname, fmsg = pycompat.sysbytes(fname), pycompat.sysbytes(fmsg)
                         self.write_err('%s at: %s:%d (%s)\n'
                                        % (msg, fname, lineno, fmsg))
                         self.log('develwarn', '%s at: %s:%d (%s)\n',
                                  msg, fname, lineno, fmsg)
                         curframe = calframe = None  # avoid cycles
                 def deprecwarn(self, msg, version, stacklevel=2):
                     """issue a deprecation warning
                     - msg: message explaining what is deprecated and how to upgrade,
                     - version: last version where the API will be supported,
                     """
                     if not (self.configbool('devel', 'all-warnings')
                             or self.configbool('devel', 'deprec-warn')):
                         return
                     msg += ("\n(compatibility will be dropped after Mercurial-%s,"
                             " update your code.)") % version
                     self.develwarn(msg, stacklevel=stacklevel, config='deprec-warn')
                 def exportableenviron(self):
                     """The environment variables that are safe to export, e.g. through
                     hgweb.
                     """
                     return self._exportableenviron
                 @contextlib.contextmanager
                 def configoverride(self, overrides, source=""):
                     """Context manager for temporary config overrides
                     `overrides` must be a dict of the following structure:
                     {(section, name) : value}"""
                     backups = {}
                     try:
                         for (section, name), value in overrides.items():
                             backups[(section, name)] = self.backupconfig(section, name)
                             self.setconfig(section, name, value, source)
                         yield
                     finally:
                         for __, backup in backups.items():
                             self.restoreconfig(backup)
                         # just restoring ui.quiet config to the previous value is not enough
                         # as it does not update ui.quiet class member
                         if ('ui', 'quiet') in overrides:
                             self.fixconfig(section='ui')
             class paths(dict):
                 """Represents a collection of paths and their configs.
                 Data is initially derived from ui instances and the config files they have
                 loaded.
                 """
                 def __init__(self, ui):
                     dict.__init__(self)
                     for name, loc in ui.configitems('paths', ignoresub=True):
                         # No location is the same as not existing.
                         if not loc:
                             continue
                         loc, sub = ui.configsuboptions('paths', name)
                         self[name] = path(ui, name, rawloc=loc, suboptions=sub)
                 def getpath(self, name, default=None):
                     """Return a ``path`` from a string, falling back to default.
                     ``name`` can be a named path or locations. Locations are filesystem
                     paths or URIs.
                     Returns None if ``name`` is not a registered path, a URI, or a local
                     path to a repo.
                     """
                     # Only fall back to default if no path was requested.
                     if name is None:
                         if not default:
                             default = ()
                         elif not isinstance(default, (tuple, list)):
                             default = (default,)
                         for k in default:
                             try:
                                 return self[k]
                             except KeyError:
                                 continue
                         return None
                     # Most likely empty string.
                     # This may need to raise in the future.
                     if not name:
                         return None
                     try:
                         return self[name]
                     except KeyError:
                         # Try to resolve as a local path or URI.
                         try:
                             # We don't pass sub-options in, so no need to pass ui instance.
                             return path(None, None, rawloc=name)
                         except ValueError:
                             raise error.RepoError(_('repository %s does not exist') %
                                                     name)
             _pathsuboptions = {}
             def pathsuboption(option, attr):
                 """Decorator used to declare a path sub-option.
                 Arguments are the sub-option name and the attribute it should set on
                 ``path`` instances.
                 The decorated function will receive as arguments a ``ui`` instance,
                 ``path`` instance, and the string value of this option from the config.
                 The function should return the value that will be set on the ``path``
                 instance.
                 This decorator can be used to perform additional verification of
                 sub-options and to change the type of sub-options.
                 """
                 def register(func):
                     _pathsuboptions[option] = (attr, func)
                     return func
                 return register
             @pathsuboption('pushurl', 'pushloc')
             def pushurlpathoption(ui, path, value):
                 u = util.url(value)
                 # Actually require a URL.
                 if not u.scheme:
                     ui.warn(_('(paths.%s:pushurl not a URL; ignoring)\n') % path.name)
                     return None
                 # Don't support the #foo syntax in the push URL to declare branch to
                 # push.
                 if u.fragment:
                     ui.warn(_('("#fragment" in paths.%s:pushurl not supported; '
                               'ignoring)\n') % path.name)
                     u.fragment = None
                 return bytes(u)
             @pathsuboption('pushrev', 'pushrev')
             def pushrevpathoption(ui, path, value):
                 return value
             class path(object):
                 """Represents an individual path and its configuration."""
                 def __init__(self, ui, name, rawloc=None, suboptions=None):
                     """Construct a path from its config options.
                     ``ui`` is the ``ui`` instance the path is coming from.
                     ``name`` is the symbolic name of the path.
                     ``rawloc`` is the raw location, as defined in the config.
                     ``pushloc`` is the raw locations pushes should be made to.
                     If ``name`` is not defined, we require that the location be a) a local
                     filesystem path with a .hg directory or b) a URL. If not,
                     ``ValueError`` is raised.
                     """
                     if not rawloc:
                         raise ValueError('rawloc must be defined')
                     # Locations may define branches via syntax <base>#<branch>.
                     u = util.url(rawloc)
                     branch = None
                     if u.fragment:
                         branch = u.fragment
                         u.fragment = None
                     self.url = u
                     self.branch = branch
                     self.name = name
                     self.rawloc = rawloc
                     self.loc = '%s' % u
                     # When given a raw location but not a symbolic name, validate the
                     # location is valid.
                     if not name and not u.scheme and not self._isvalidlocalpath(self.loc):
                         raise ValueError('location is not a URL or path to a local '
                                          'repo: %s' % rawloc)
                     suboptions = suboptions or {}
                     # Now process the sub-options. If a sub-option is registered, its
                     # attribute will always be present. The value will be None if there
                     # was no valid sub-option.
                     for suboption, (attr, func) in _pathsuboptions.iteritems():
                         if suboption not in suboptions:
                             setattr(self, attr, None)
                             continue
                         value = func(ui, self, suboptions[suboption])
                         setattr(self, attr, value)
                 def _isvalidlocalpath(self, path):
                     """Returns True if the given path is a potentially valid repository.
                     This is its own function so that extensions can change the definition of
                     'valid' in this case (like when pulling from a git repo into a hg
                     one)."""
                     return os.path.isdir(os.path.join(path, '.hg'))
                 @property
                 def suboptions(self):
                     """Return sub-options and their values for this path.
                     This is intended to be used for presentation purposes.
                     """
                     d = {}
                     for subopt, (attr, _func) in _pathsuboptions.iteritems():
                         value = getattr(self, attr)
                         if value is not None:
                             d[subopt] = value
                     return d
             # we instantiate one globally shared progress bar to avoid
             # competing progress bars when multiple UI objects get created
             _progresssingleton = None
             def getprogbar(ui):
                 global _progresssingleton
                 if _progresssingleton is None:
                     # passing 'ui' object to the singleton is fishy,
                     # this is how the extension used to work but feel free to rework it.
                     _progresssingleton = progress.progbar(ui)
                 return _progresssingleton
             def haveprogbar():
                 return _progresssingleton is not None