/brz/remove-bazaar : revision 893

15

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

16

17

18

# TODO: Split the command framework away from the actual commands.

19

20

# TODO: probably should say which arguments are candidates for glob

21

# expansion on windows and do that at the command level.

22

23

import sys

24

import os

18

19

import sys, os

25

20

26

21

import bzrlib

27

from bzrlib.trace import mutter, note, log_error, warning

22

from bzrlib.trace import mutter, note, log_error

28

23

from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError

29

24

from bzrlib.branch import find_branch

30

25

from bzrlib import BZRDIR

56

51

assert cmd.startswith("cmd_")

57

52

return cmd[4:].replace('_','-')

58

53

59

60

54

def _parse_revision_str(revstr):

61

"""This handles a revision string -> revno.

62

63

This always returns a list. The list will have one element for

64

65

It supports integers directly, but everything else it

66

defers for passing to Branch.get_revision_info()

67

68

>>> _parse_revision_str('234')

69

[234]

70

>>> _parse_revision_str('234..567')

71

[234, 567]

72

>>> _parse_revision_str('..')

73

[None, None]

74

>>> _parse_revision_str('..234')

75

[None, 234]

76

>>> _parse_revision_str('234..')

77

[234, None]

78

>>> _parse_revision_str('234..456..789') # Maybe this should be an error

79

[234, 456, 789]

80

>>> _parse_revision_str('234....789') # Error?

81

[234, None, 789]

82

>>> _parse_revision_str('revid:test@other.com-234234')

83

['revid:test@other.com-234234']

84

>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')

85

['revid:test@other.com-234234', 'revid:test@other.com-234235']

86

>>> _parse_revision_str('revid:test@other.com-234234..23')

87

['revid:test@other.com-234234', 23]

88

>>> _parse_revision_str('date:2005-04-12')

89

['date:2005-04-12']

90

>>> _parse_revision_str('date:2005-04-12 12:24:33')

91

['date:2005-04-12 12:24:33']

92

>>> _parse_revision_str('date:2005-04-12T12:24:33')

93

['date:2005-04-12T12:24:33']

94

>>> _parse_revision_str('date:2005-04-12,12:24:33')

95

['date:2005-04-12,12:24:33']

96

>>> _parse_revision_str('-5..23')

97

[-5, 23]

98

>>> _parse_revision_str('-5')

99

[-5]

100

>>> _parse_revision_str('123a')

101

['123a']

102

>>> _parse_revision_str('abc')

103

['abc']

55

"""This handles a revision string -> revno.

56

57

There are several possibilities:

58

59

'234' -> 234

60

'234:345' -> [234, 345]

61

':234' -> [None, 234]

62

'234:' -> [234, None]

63

64

In the future we will also support:

65

'uuid:blah-blah-blah' -> ?

66

'hash:blahblahblah' -> ?

67

potentially:

68

'tag:mytag' -> ?

104

69

"""

105

import re

106

old_format_re = re.compile('\d*:\d*')

107

m = old_format_re.match(revstr)

108

if m:

109

warning('Colon separator for revision numbers is deprecated.'

110

' Use .. instead')

111

revs = []

112

for rev in revstr.split(':'):

113

if rev:

114

revs.append(int(rev))

115

else:

116

revs.append(None)

117

return revs

118

revs = []

119

for x in revstr.split('..'):

120

if not x:

121

revs.append(None)

122

else:

123

try:

124

revs.append(int(x))

125

except ValueError:

126

revs.append(x)

70

if revstr.find(':') != -1:

71

revs = revstr.split(':')

72

if len(revs) > 2:

73

raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)

74

75

if not revs[0]:

76

revs[0] = None

77

else:

78

revs[0] = int(revs[0])

79

80

if not revs[1]:

81

revs[1] = None

82

else:

83

revs[1] = int(revs[1])

84

else:

85

revs = int(revstr)

127

86

return revs

128

87

129

88

130

def get_merge_type(typestring):

131

"""Attempt to find the merge class/factory associated with a string."""

132

from merge import merge_types

133

try:

134

return merge_types[typestring][0]

135

except KeyError:

136

templ = '%s%%7s: %%s' % (' '*12)

137

lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]

138

type_list = '\n'.join(lines)

139

msg = "No known merge type %s. Supported types are:\n%s" %\

140

(typestring, type_list)

141

raise BzrCommandError(msg)

142

143

144

89

145

90

def _get_cmd_dict(plugins_override=True):

146

91

d = {}

219

164

assert isinstance(arguments, dict)

220

165

cmdargs = options.copy()

221

166

cmdargs.update(arguments)

222

if self.__doc__ == Command.__doc__:

223

from warnings import warn

224

warn("No help message set for %r" % self)

167

assert self.__doc__ != Command.__doc__, \

168

("No help message set for %r" % self)

225

169

self.status = self.run(**cmdargs)

226

if self.status is None:

227

self.status = 0

228

170

229

171

230

172

def run(self):

242

184

class ExternalCommand(Command):

243

185

"""Class to wrap external commands.

244

186

245

We cheat a little here, when get_cmd_class() calls us we actually

246

give it back an object we construct that has the appropriate path,

247

help, options etc for the specified command.

248

249

When run_bzr() tries to instantiate that 'class' it gets caught by

250

the __call__ method, which we override to call the Command.__init__

251

method. That then calls our run method which is pretty straight

252

forward.

253

254

The only wrinkle is that we have to map bzr's dictionary of options

255

and arguments back into command line options and arguments for the

256

script.

187

We cheat a little here, when get_cmd_class() calls us we actually give it back

188

an object we construct that has the appropriate path, help, options etc for the

189

specified command.

190

191

When run_bzr() tries to instantiate that 'class' it gets caught by the __call__

192

method, which we override to call the Command.__init__ method. That then calls

193

our run method which is pretty straight forward.

194

195

The only wrinkle is that we have to map bzr's dictionary of options and arguments

196

back into command line options and arguments for the script.

257

197

"""

258

198

259

199

def find_command(cls, cmd):

356

296

directory is shown. Otherwise, only the status of the specified

357

297

files or directories is reported. If a directory is given, status

358

298

is reported for everything inside that directory.

359

360

If a revision is specified, the changes since that revision are shown.

361

299

"""

362

300

takes_args = ['file*']

363

takes_options = ['all', 'show-ids', 'revision']

301

takes_options = ['all', 'show-ids']

364

302

aliases = ['st', 'stat']

365

303

366

304

def run(self, all=False, show_ids=False, file_list=None):

373

311

file_list = None

374

312

else:

375

313

b = find_branch('.')

376

377

from bzrlib.status import show_status

378

show_status(b, show_unchanged=all, show_ids=show_ids,

379

specific_files=file_list)

314

import status

315

status.show_status(b, show_unchanged=all, show_ids=show_ids,

316

specific_files=file_list)

380

317

381

318

382

319

class cmd_cat_revision(Command):

397

334

def run(self):

398

335

print find_branch('.').revno()

399

336

400

class cmd_revision_info(Command):

401

"""Show revision number and revision id for a given revision identifier.

402

"""

403

hidden = True

404

takes_args = ['revision_info*']

405

takes_options = ['revision']

406

def run(self, revision=None, revision_info_list=None):

407

from bzrlib.branch import find_branch

408

409

revs = []

410

if revision is not None:

411

revs.extend(revision)

412

if revision_info_list is not None:

413

revs.extend(revision_info_list)

414

if len(revs) == 0:

415

raise BzrCommandError('You must supply a revision identifier')

416

417

b = find_branch('.')

418

419

for rev in revs:

420

print '%4d %s' % b.get_revision_info(rev)

421

422

337

423

338

class cmd_add(Command):

424

339

"""Add specified files or directories.

433

348

whether already versioned or not, are searched for files or

434

349

subdirectories that are neither versioned or ignored, and these

435

350

are added. This search proceeds recursively into versioned

436

directories. If no names are given '.' is assumed.

351

directories.

437

352

438

Therefore simply saying 'bzr add' will version all files that

353

Therefore simply saying 'bzr add .' will version all files that

439

354

are currently unknown.

440

355

441

356

TODO: Perhaps adding a file whose directly is not versioned should

442

357

recursively add that parent, rather than giving an error?

443

358

"""

444

takes_args = ['file*']

359

takes_args = ['file+']

445

360

takes_options = ['verbose', 'no-recurse']

446

361

447

362

def run(self, file_list, verbose=False, no_recurse=False):

486

401

if revision == None:

487

402

inv = b.read_working_inventory()

488

403

else:

489

if len(revision) > 1:

490

raise BzrCommandError('bzr inventory --revision takes'

491

' exactly one revision identifier')

492

inv = b.get_revision_inventory(b.lookup_revision(revision[0]))

404

inv = b.get_revision_inventory(b.lookup_revision(revision))

493

405

494

406

for path, entry in inv.entries():

495

407

if show_ids:

510

422

def run(self, source_list, dest):

511

423

b = find_branch('.')

512

424

513

# TODO: glob expansion on windows?

514

425

b.move([b.relpath(s) for s in source_list], b.relpath(dest))

515

426

516

427

536

447

537

448

538

449

539

class cmd_mv(Command):

540

"""Move or rename a file.

541

542

usage:

543

bzr mv OLDNAME NEWNAME

544

bzr mv SOURCE... DESTINATION

545

546

If the last argument is a versioned directory, all the other names

547

are moved into it. Otherwise, there must be exactly two arguments

548

and the file is changed to a new name, which must not already exist.

549

550

Files cannot be moved between branches.

551

"""

552

takes_args = ['names*']

553

def run(self, names_list):

554

if len(names_list) < 2:

555

raise BzrCommandError("missing file argument")

556

b = find_branch(names_list[0])

557

558

rel_names = [b.relpath(x) for x in names_list]

559

560

if os.path.isdir(names_list[-1]):

561

# move into existing directory

562

b.move(rel_names[:-1], rel_names[-1])

563

else:

564

if len(names_list) != 2:

565

raise BzrCommandError('to mv multiple files the destination '

566

'must be a versioned directory')

567

b.move(rel_names[0], rel_names[1])

568

569

570

450

571

451

572

452

class cmd_pull(Command):

639

519

"""

640

520

takes_args = ['from_location', 'to_location?']

641

521

takes_options = ['revision']

642

aliases = ['get', 'clone']

643

522

644

523

def run(self, from_location, to_location=None, revision=None):

645

524

import errno

646

525

from bzrlib.merge import merge

647

from bzrlib.branch import DivergedBranches, \

526

from bzrlib.branch import DivergedBranches, NoSuchRevision, \

648

527

find_cached_branch, Branch

649

528

from shutil import rmtree

650

529

from meta_store import CachedStore

651

530

import tempfile

652

531

cache_root = tempfile.mkdtemp()

653

654

if revision is None:

655

revision = [None]

656

elif len(revision) > 1:

657

raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')

658

659

532

try:

660

533

try:

661

534

br_from = find_cached_branch(from_location, cache_root)

682

555

raise

683

556

br_to = Branch(to_location, init=True)

684

557

685

br_to.set_root_id(br_from.get_root_id())

686

687

if revision:

688

if revision[0] is None:

689

revno = br_from.revno()

690

else:

691

revno, rev_id = br_from.get_revision_info(revision[0])

692

try:

693

br_to.update_revisions(br_from, stop_revision=revno)

694

except bzrlib.errors.NoSuchRevision:

695

rmtree(to_location)

696

msg = "The branch %s has no revision %d." % (from_location,

697

revno)

698

raise BzrCommandError(msg)

699

558

try:

559

br_to.update_revisions(br_from, stop_revision=revision)

560

except NoSuchRevision:

561

rmtree(to_location)

562

msg = "The branch %s has no revision %d." % (from_location,

563

revision)

564

raise BzrCommandError(msg)

700

565

merge((to_location, -1), (to_location, 0), this_dir=to_location,

701

566

check_clean=False, ignore_zero=True)

702

567

from_location = pull_loc(br_from)

870

735

file_list = None

871

736

else:

872

737

b = find_branch('.')

873

874

# TODO: Make show_diff support taking 2 arguments

875

base_rev = None

876

if revision is not None:

877

if len(revision) != 1:

878

raise BzrCommandError('bzr diff --revision takes exactly one revision identifier')

879

base_rev = revision[0]

880

738

881

show_diff(b, base_rev, specific_files=file_list,

739

show_diff(b, revision, specific_files=file_list,

882

740

external_diff_options=diff_options)

883

741

884

742

912

770

"""List files modified in working tree."""

913

771

hidden = True

914

772

def run(self):

915

from bzrlib.delta import compare_trees

773

from bzrlib.diff import compare_trees

916

774

917

775

b = find_branch('.')

918

776

td = compare_trees(b.basis_tree(), b.working_tree())

959

817

-r revision requests a specific revision, -r :end or -r begin: are

960

818

also valid.

961

819

962

--message allows you to give a regular expression, which will be evaluated

963

so that only matching entries will be displayed.

964

965

820

TODO: Make --revision support uuid: and hash: [future tag:] notation.

966

821

967

822

"""

968

823

969

824

takes_args = ['filename?']

970

takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision','long', 'message']

825

takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision','long']

971

826

972

827

def run(self, filename=None, timezone='original',

973

828

verbose=False,

974

829

show_ids=False,

975

830

forward=False,

976

831

revision=None,

977

message=None,

978

832

long=False):

979

833

from bzrlib.branch import find_branch

980

834

from bzrlib.log import log_formatter, show_log

993

847

b = find_branch('.')

994

848

file_id = None

995

849

996

if revision is None:

997

rev1 = None

998

rev2 = None

999

elif len(revision) == 1:

1000

rev1 = rev2 = b.get_revision_info(revision[0])[0]

1001

elif len(revision) == 2:

1002

rev1 = b.get_revision_info(revision[0])[0]

1003

rev2 = b.get_revision_info(revision[1])[0]

850

if revision == None:

851

revision = [None, None]

852

elif isinstance(revision, int):

853

revision = [revision, revision]

1004

854

else:

1005

raise BzrCommandError('bzr log --revision takes one or two values.')

1006

1007

if rev1 == 0:

1008

rev1 = None

1009

if rev2 == 0:

1010

rev2 = None

855

# pair of revisions?

856

pass

857

858

assert len(revision) == 2

1011

859

1012

860

mutter('encoding log as %r' % bzrlib.user_encoding)

1013

861

1029

877

file_id,

1030

878

verbose=verbose,

1031

879

direction=direction,

1032

start_revision=rev1,

1033

end_revision=rev2,

1034

search=message)

880

start_revision=revision[0],

881

end_revision=revision[1])

1035

882

1036

883

1037

884

1193

1040

def run(self, dest, revision=None, format=None, root=None):

1194

1041

import os.path

1195

1042

b = find_branch('.')

1196

if revision is None:

1197

rev_id = b.last_patch()

1043

if revision == None:

1044

rh = b.revision_history()[-1]

1198

1045

else:

1199

if len(revision) != 1:

1200

raise BzrError('bzr export --revision takes exactly 1 argument')

1201

revno, rev_id = b.get_revision_info(revision[0])

1202

t = b.revision_tree(rev_id)

1046

rh = b.lookup_revision(int(revision))

1047

t = b.revision_tree(rh)

1203

1048

root, ext = os.path.splitext(dest)

1204

1049

if not format:

1205

1050

if ext in (".tar",):

1222

1067

def run(self, filename, revision=None):

1223

1068

if revision == None:

1224

1069

raise BzrCommandError("bzr cat requires a revision number")

1225

elif len(revision) != 1:

1226

raise BzrCommandError("bzr cat --revision takes exactly one number")

1227

1070

b = find_branch('.')

1228

b.print_file(b.relpath(filename), revision[0])

1071

b.print_file(b.relpath(filename), int(revision))

1229

1072

1230

1073

1231

1074

class cmd_local_time_offset(Command):

1238

1081

1239

1082

class cmd_commit(Command):

1240

1083

"""Commit changes into a new revision.

1241

1242

If no arguments are given, the entire tree is committed.

1243

1084

1244

1085

If selected files are specified, only changes to those files are

1245

committed. If a directory is specified then the directory and everything

1246

within it is committed.

1086

committed. If a directory is specified then its contents are also

1087

committed.

1247

1088

1248

1089

A selected-file commit may fail in some cases where the committed

1249

1090

tree would be invalid, such as trying to commit a file in a

1257

1098

takes_options = ['message', 'file', 'verbose', 'unchanged']

1258

1099

aliases = ['ci', 'checkin']

1259

1100

1260

# TODO: Give better message for -s, --summary, used by tla people

1261

1262

1101

def run(self, message=None, file=None, verbose=True, selected_list=None,

1263

1102

unchanged=False):

1264

1103

from bzrlib.errors import PointlessCommit

1266

1105

1267

1106

## Warning: shadows builtin file()

1268

1107

if not message and not file:

1269

# FIXME: Ugly; change status code to send to a provided function?

1270

1271

1108

import cStringIO

1272

1109

stdout = sys.stdout

1273

1110

catcher = cStringIO.StringIO()

1288

1125

message = codecs.open(file, 'rt', bzrlib.user_encoding).read()

1289

1126

1290

1127

b = find_branch('.')

1291

if selected_list:

1292

selected_list = [b.relpath(s) for s in selected_list]

1293

1128

1294

1129

try:

1295

1130

b.commit(message, verbose=verbose,

1296

1131

specific_files=selected_list,

1319

1154

1320

1155

1321

1156

1322

class cmd_scan_cache(Command):

1323

hidden = True

1324

def run(self):

1325

from bzrlib.hashcache import HashCache

1326

import os

1327

1328

c = HashCache('.')

1329

c.read()

1330

c.scan()

1331

1332

print '%6d stats' % c.stat_count

1333

print '%6d in hashcache' % len(c._cache)

1334

print '%6d files removed from cache' % c.removed_count

1335

print '%6d hashes updated' % c.update_count

1336

print '%6d files changed too recently to cache' % c.danger_count

1337

1338

if c.needs_write:

1339

c.write()

1340

1341

1342

1343

1157

class cmd_upgrade(Command):

1344

1158

"""Upgrade branch storage to current format.

1345

1159

1368

1182

class cmd_selftest(Command):

1369

1183

"""Run internal test suite"""

1370

1184

hidden = True

1371

takes_options = ['verbose']

1372

def run(self, verbose=False):

1185

def run(self):

1373

1186

from bzrlib.selftest import selftest

1374

return int(not selftest(verbose=verbose))

1187

return int(not selftest())

1375

1188

1376

1189

1377

1190

class cmd_version(Command):

1409

1222

['..', -1]

1410

1223

>>> parse_spec("../f/@35")

1411

1224

['../f', 35]

1412

>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')

1413

['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']

1414

1225

"""

1415

1226

if spec is None:

1416

1227

return [None, None]

1420

1231

if parsed[1] == "":

1421

1232

parsed[1] = -1

1422

1233

else:

1423

try:

1424

parsed[1] = int(parsed[1])

1425

except ValueError:

1426

pass # We can allow stuff like ./@revid:blahblahblah

1427

else:

1428

assert parsed[1] >=0

1234

parsed[1] = int(parsed[1])

1235

assert parsed[1] >=0

1429

1236

else:

1430

1237

parsed = [spec, None]

1431

1238

return parsed

1455

1262

--force is given.

1456

1263

"""

1457

1264

takes_args = ['other_spec', 'base_spec?']

1458

takes_options = ['force', 'merge-type']

1265

takes_options = ['force']

1459

1266

1460

def run(self, other_spec, base_spec=None, force=False, merge_type=None):

1267

def run(self, other_spec, base_spec=None, force=False):

1461

1268

from bzrlib.merge import merge

1462

from bzrlib.merge_core import ApplyMerge3

1463

if merge_type is None:

1464

merge_type = ApplyMerge3

1465

1269

merge(parse_spec(other_spec), parse_spec(base_spec),

1466

check_clean=(not force), merge_type=merge_type)

1270

check_clean=(not force))

1271

1467

1272

1468

1273

1469

1274

class cmd_revert(Command):

1275

"""Restore selected files from a previous revision.

1276

"""

1277

takes_args = ['file+']

1278

def run(self, file_list):

1279

from bzrlib.branch import find_branch

1280

1281

if not file_list:

1282

file_list = ['.']

1283

1284

b = find_branch(file_list[0])

1285

1286

b.revert([b.relpath(f) for f in file_list])

1287

1288

1289

class cmd_merge_revert(Command):

1470

1290

"""Reverse all changes since the last commit.

1471

1291

1472

Only versioned files are affected. Specify filenames to revert only

1473

those files. By default, any files that are changed will be backed up

1474

first. Backup files have a '~' appended to their name.

1292

Only versioned files are affected.

1293

1294

TODO: Store backups of any files that will be reverted, so

1295

that the revert can be undone.

1475

1296

"""

1476

takes_options = ['revision', 'no-backup']

1477

takes_args = ['file*']

1478

aliases = ['merge-revert']

1297

takes_options = ['revision']

1479

1298

1480

def run(self, revision=None, no_backup=False, file_list=None):

1299

def run(self, revision=-1):

1481

1300

from bzrlib.merge import merge

1482

if file_list is not None:

1483

if len(file_list) == 0:

1484

raise BzrCommandError("No files specified")

1485

if revision is None:

1486

revision = [-1]

1487

elif len(revision) != 1:

1488

raise BzrCommandError('bzr revert --revision takes exactly 1 argument')

1489

merge(('.', revision[0]), parse_spec('.'),

1301

merge(('.', revision), parse_spec('.'),

1490

1302

check_clean=False,

1491

ignore_zero=True,

1492

backup_files=not no_backup,

1493

file_list=file_list)

1303

ignore_zero=True)

1494

1304

1495

1305

1496

1306

class cmd_assert_fail(Command):

1519

1329

hidden = True

1520

1330

def run(self):

1521

1331

import bzrlib.plugin

1522

from inspect import getdoc

1523

1332

from pprint import pprint

1524

for plugin in bzrlib.plugin.all_plugins:

1525

print plugin.__path__[0]

1526

d = getdoc(plugin)

1527

if d:

1528

print '\t', d.split('\n')[0]

1529

1530

#pprint(bzrlib.plugin.all_plugins)

1333

pprint(bzrlib.plugin.all_plugins)

1531

1334

1532

1335

1533

1336

1555

1358

'update': None,

1556

1359

'long': None,

1557

1360

'root': str,

1558

'no-backup': None,

1559

'merge-type': get_merge_type,

1560

1361

}

1561

1362

1562

1363

SHORT_OPTIONS = {

1586

1387

>>> parse_args('commit --message=biter'.split())

1587

1388

(['commit'], {'message': u'biter'})

1588

1389

>>> parse_args('log -r 500'.split())

1589

(['log'], {'revision': [500]})

1590

>>> parse_args('log -r500..600'.split())

1390

(['log'], {'revision': 500})

1391

>>> parse_args('log -r500:600'.split())

1591

1392

(['log'], {'revision': [500, 600]})

1592

>>> parse_args('log -vr500..600'.split())

1393

>>> parse_args('log -vr500:600'.split())

1593

1394

(['log'], {'verbose': True, 'revision': [500, 600]})

1594

>>> parse_args('log -rv500..600'.split()) #the r takes an argument

1595

(['log'], {'revision': ['v500', 600]})

1395

>>> parse_args('log -rv500:600'.split()) #the r takes an argument

1396

Traceback (most recent call last):

1397

...

1398

ValueError: invalid literal for int(): v500

1596

1399

"""

1597

1400

args = []

1598

1401

opts = {}

1712

1515

return argdict

1713

1516

1714

1517

1518

def _parse_master_args(argv):

1519

"""Parse the arguments that always go with the original command.

1520

These are things like bzr --no-plugins, etc.

1521

1522

There are now 2 types of option flags. Ones that come *before* the command,

1523

and ones that come *after* the command.

1524

Ones coming *before* the command are applied against all possible commands.

1525

And are generally applied before plugins are loaded.

1526

1527

The current list are:

1528

--builtin Allow plugins to load, but don't let them override builtin commands,

1529

they will still be allowed if they do not override a builtin.

1530

--no-plugins Don't load any plugins. This lets you get back to official source

1531

behavior.

1532

--profile Enable the hotspot profile before running the command.

1533

For backwards compatibility, this is also a non-master option.

1534

--version Spit out the version of bzr that is running and exit.

1535

This is also a non-master option.

1536

--help Run help and exit, also a non-master option (I think that should stay, though)

1537

1538

>>> argv, opts = _parse_master_args(['bzr', '--test'])

1539

Traceback (most recent call last):

1540

...

1541

BzrCommandError: Invalid master option: 'test'

1542

>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])

1543

>>> print argv

1544

['command']

1545

>>> print opts['version']

1546

True

1547

>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])

1548

>>> print argv

1549

['command', '--more-options']

1550

>>> print opts['profile']

1551

True

1552

>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])

1553

>>> print argv

1554

['command']

1555

>>> print opts['no-plugins']

1556

True

1557

>>> print opts['profile']

1558

False

1559

>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])

1560

>>> print argv

1561

['command', '--profile']

1562

>>> print opts['profile']

1563

False

1564

"""

1565

master_opts = {'builtin':False,

1566

'no-plugins':False,

1567

'version':False,

1568

'profile':False,

1569

'help':False

1570

}

1571

1572

# This is the point where we could hook into argv[0] to determine

1573

# what front-end is supposed to be run

1574

# For now, we are just ignoring it.

1575

cmd_name = argv.pop(0)

1576

for arg in argv[:]:

1577

if arg[:2] != '--': # at the first non-option, we return the rest

1578

break

1579

arg = arg[2:] # Remove '--'

1580

if arg not in master_opts:

1581

# We could say that this is not an error, that we should

1582

# just let it be handled by the main section instead

1583

raise BzrCommandError('Invalid master option: %r' % arg)

1584

argv.pop(0) # We are consuming this entry

1585

master_opts[arg] = True

1586

return argv, master_opts

1587

1588

1715

1589

1716

1590

def run_bzr(argv):

1717

1591

"""Execute a command.

1718

1592

1719

1593

This is similar to main(), but without all the trappings for

1720

1594

logging and error handling.

1721

1722

argv

1723

The command-line arguments, without the program name from argv[0]

1724

1725

Returns a command status or raises an exception.

1726

1727

Special master options: these must come before the command because

1728

they control how the command is interpreted.

1729

1730

--no-plugins

1731

Do not load plugin modules at all

1732

1733

--builtin

1734

Only use builtin commands. (Plugins are still allowed to change

1735

other behaviour.)

1736

1737

--profile

1738

Run under the Python profiler.

1739

1595

"""

1740

1741

1596

argv = [a.decode(bzrlib.user_encoding) for a in argv]

1742

1743

opt_profile = opt_no_plugins = opt_builtin = False

1744

1745

# --no-plugins is handled specially at a very early stage. We need

1746

# to load plugins before doing other command parsing so that they

1747

# can override commands, but this needs to happen first.

1748

1749

for a in argv[:]:

1750

if a == '--profile':

1751

opt_profile = True

1752

elif a == '--no-plugins':

1753

opt_no_plugins = True

1754

elif a == '--builtin':

1755

opt_builtin = True

1756

else:

1757

break

1758

argv.remove(a)

1759

1760

if not opt_no_plugins:

1761

from bzrlib.plugin import load_plugins

1762

load_plugins()

1763

1764

args, opts = parse_args(argv)

1765

1766

if 'help' in opts:

1767

from bzrlib.help import help

1768

if args:

1769

help(args[0])

1770

else:

1771

help()

1772

return 0

1773

1774

if 'version' in opts:

1775

show_version()

1776

return 0

1777

1597

1778

if not args:

1779

print >>sys.stderr, "please try 'bzr help' for help"

1598

try:

1599

# some options like --builtin and --no-plugins have special effects

1600

argv, master_opts = _parse_master_args(argv)

1601

if not master_opts['no-plugins']:

1602

from bzrlib.plugin import load_plugins

1603

load_plugins()

1604

1605

args, opts = parse_args(argv)

1606

1607

if master_opts['help']:

1608

from bzrlib.help import help

1609

if argv:

1610

help(argv[0])

1611

else:

1612

help()

1613

return 0

1614

1615

if 'help' in opts:

1616

from bzrlib.help import help

1617

if args:

1618

help(args[0])

1619

else:

1620

help()

1621

return 0

1622

elif 'version' in opts:

1623

show_version()

1624

return 0

1625

elif args and args[0] == 'builtin':

1626

include_plugins=False

1627

args = args[1:]

1628

cmd = str(args.pop(0))

1629

except IndexError:

1630

import help

1631

help.help()

1780

1632

return 1

1781

1782

cmd = str(args.pop(0))

1783

1784

canonical_cmd, cmd_class = \

1785

get_cmd_class(cmd, plugins_override=not opt_builtin)

1633

1634

1635

plugins_override = not (master_opts['builtin'])

1636

canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)

1637

1638

profile = master_opts['profile']

1639

# For backwards compatibility, I would rather stick with --profile being a

1640

# master/global option

1641

if 'profile' in opts:

1642

profile = True

1643

del opts['profile']

1786

1644

1787

1645

# check options are reasonable

1788

1646

allowed = cmd_class.takes_options

1797

1655

for k, v in opts.items():

1798

1656

cmdopts[k.replace('-', '_')] = v

1799

1657

1800

if opt_profile:

1658

if profile:

1801

1659

import hotshot, tempfile

1802

1660

pffileno, pfname = tempfile.mkstemp()

1803

1661

try:

1824

1682

1825

1683

def _report_exception(summary, quiet=False):

1826

1684

import traceback

1827

1828

1685

log_error('bzr: ' + summary)

1829

1686

bzrlib.trace.log_exception()

1830

1687

1831

if os.environ.get('BZR_DEBUG'):

1832

traceback.print_exc()

1833

1834

1688

if not quiet:

1835

sys.stderr.write('\n')

1836

1689

tb = sys.exc_info()[2]

1837

1690

exinfo = traceback.extract_tb(tb)

1838

1691

if exinfo:

1848

1701

try:

1849

1702

try:

1850

1703

try:

1851

return run_bzr(argv[1:])

1704

return run_bzr(argv)

1852

1705

finally:

1853

1706

# do this here inside the exception wrappers to catch EPIPE

1854

1707

sys.stdout.flush()

1855

1708

except BzrError, e:

1856

1709

quiet = isinstance(e, (BzrCommandError))

1857

_report_exception('error: ' + str(e), quiet=quiet)

1710

_report_exception('error: ' + e.args[0], quiet=quiet)

1858

1711

if len(e.args) > 1:

1859

1712

for h in e.args[1]:

1860

1713

# some explanation or hints