/brz/remove-bazaar : revision 854

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

916

773

from bzrlib.statcache import update_cache, SC_SHA1

917

774

b = find_branch('.')

918

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

775

inv = b.read_working_inventory()

776

sc = update_cache(b, inv)

777

basis = b.basis_tree()

778

basis_inv = basis.inventory

779

780

# We used to do this through iter_entries(), but that's slow

781

# when most of the files are unmodified, as is usually the

782

# case. So instead we iterate by inventory entry, and only

783

# calculate paths as necessary.

919

784

920

for path, id, kind in td.modified:

921

print path

785

for file_id in basis_inv:

786

cacheentry = sc.get(file_id)

787

if not cacheentry: # deleted

788

continue

789

ie = basis_inv[file_id]

790

if cacheentry[SC_SHA1] != ie.text_sha1:

791

path = inv.id2path(file_id)

792

print path

922

793

923

794

924

795

959

830

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

960

831

also valid.

961

832

962

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

963

so that only matching entries will be displayed.

964

965

833

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

966

834

967

835

"""

968

836

969

837

takes_args = ['filename?']

970

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

838

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

971

839

972

840

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

973

841

verbose=False,

974

842

show_ids=False,

975

843

forward=False,

976

844

revision=None,

977

message=None,

978

845

long=False):

979

846

from bzrlib.branch import find_branch

980

847

from bzrlib.log import log_formatter, show_log

993

860

b = find_branch('.')

994

861

file_id = None

995

862

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]

863

if revision == None:

864

revision = [None, None]

865

elif isinstance(revision, int):

866

revision = [revision, revision]

1004

867

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

868

# pair of revisions?

869

pass

870

871

assert len(revision) == 2

1011

872

1012

873

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

1013

874

1029

890

file_id,

1030

891

verbose=verbose,

1031

892

direction=direction,

1032

start_revision=rev1,

1033

end_revision=rev2,

1034

search=message)

893

start_revision=revision[0],

894

end_revision=revision[1])

1035

895

1036

896

1037

897

1182

1042

If no revision is specified this exports the last committed revision.

1183

1043

1184

1044

Format may be an "exporter" name, such as tar, tgz, tbz2. If none is

1185

given, try to find the format with the extension. If no extension

1186

is found exports to a directory (equivalent to --format=dir).

1045

given, exports to a directory (equivalent to --format=dir).

1187

1046

1188

Root may be the top directory for tar, tgz and tbz2 formats. If none

1189

is given, the top directory will be the root name of the file."""

1047

Root may be the top directory for tar, tgz and tbz2 formats."""

1190

1048

# TODO: list known exporters

1191

1049

takes_args = ['dest']

1192

1050

takes_options = ['revision', 'format', 'root']

1193

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

1194

import os.path

1051

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

1195

1052

b = find_branch('.')

1196

if revision is None:

1197

rev_id = b.last_patch()

1053

if revision == None:

1054

rh = b.revision_history()[-1]

1198

1055

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)

1203

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

1204

if not format:

1205

if ext in (".tar",):

1206

format = "tar"

1207

elif ext in (".gz", ".tgz"):

1208

format = "tgz"

1209

elif ext in (".bz2", ".tbz2"):

1210

format = "tbz2"

1211

else:

1212

format = "dir"

1056

rh = b.lookup_revision(int(revision))

1057

t = b.revision_tree(rh)

1213

1058

t.export(dest, format, root)

1214

1059

1215

1060

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

1254

1095

TODO: Strict commit that fails if there are unknown or deleted files.

1255

1096

"""

1256

1097

takes_args = ['selected*']

1257

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

1098

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

1258

1099

aliases = ['ci', 'checkin']

1259

1100

1260

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

1261

1262

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

1263

unchanged=False):

1264

from bzrlib.errors import PointlessCommit

1101

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

1102

from bzrlib.commit import commit

1265

1103

from bzrlib.osutils import get_text_message

1266

1104

1267

1105

## Warning: shadows builtin file()

1268

1106

if not message and not file:

1269

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

1270

1271

1107

import cStringIO

1272

1108

stdout = sys.stdout

1273

1109

catcher = cStringIO.StringIO()

1288

1124

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

1289

1125

1290

1126

b = find_branch('.')

1291

if selected_list:

1292

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

1293

1294

try:

1295

b.commit(message, verbose=verbose,

1296

specific_files=selected_list,

1297

allow_pointless=unchanged)

1298

except PointlessCommit:

1299

# FIXME: This should really happen before the file is read in;

1300

# perhaps prepare the commit; get the message; then actually commit

1301

raise BzrCommandError("no changes to commit",

1302

["use --unchanged to commit anyhow"])

1127

commit(b, message, verbose=verbose, specific_files=selected_list)

1303

1128

1304

1129

1305

1130

class cmd_check(Command):

1319

1144

1320

1145

1321

1146

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

1147

class cmd_upgrade(Command):

1344

1148

"""Upgrade branch storage to current format.

1345

1149

1368

1172

class cmd_selftest(Command):

1369

1173

"""Run internal test suite"""

1370

1174

hidden = True

1371

takes_options = ['verbose']

1372

def run(self, verbose=False):

1175

def run(self):

1373

1176

from bzrlib.selftest import selftest

1374

return int(not selftest(verbose=verbose))

1177

return int(not selftest())

1375

1178

1376

1179

1377

1180

class cmd_version(Command):

1409

1212

['..', -1]

1410

1213

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

1411

1214

['../f', 35]

1412

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

1413

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

1414

1215

"""

1415

1216

if spec is None:

1416

1217

return [None, None]

1420

1221

if parsed[1] == "":

1421

1222

parsed[1] = -1

1422

1223

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

1224

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

1225

assert parsed[1] >=0

1429

1226

else:

1430

1227

parsed = [spec, None]

1431

1228

return parsed

1455

1252

--force is given.

1456

1253

"""

1457

1254

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

1458

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

1255

takes_options = ['force']

1459

1256

1460

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

1257

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

1461

1258

from bzrlib.merge import merge

1462

from bzrlib.merge_core import ApplyMerge3

1463

if merge_type is None:

1464

merge_type = ApplyMerge3

1465

1259

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

1466

check_clean=(not force), merge_type=merge_type)

1260

check_clean=(not force))

1261

1467

1262

1468

1263

1469

1264

class cmd_revert(Command):

1265

"""Restore selected files from a previous revision.

1266

"""

1267

takes_args = ['file+']

1268

def run(self, file_list):

1269

from bzrlib.branch import find_branch

1270

1271

if not file_list:

1272

file_list = ['.']

1273

1274

b = find_branch(file_list[0])

1275

1276

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

1277

1278

1279

class cmd_merge_revert(Command):

1470

1280

"""Reverse all changes since the last commit.

1471

1281

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.

1282

Only versioned files are affected.

1283

1284

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

1285

that the revert can be undone.

1475

1286

"""

1476

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

1477

takes_args = ['file*']

1478

aliases = ['merge-revert']

1287

takes_options = ['revision']

1479

1288

1480

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

1289

def run(self, revision=-1):

1481

1290

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('.'),

1291

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

1490

1292

check_clean=False,

1491

ignore_zero=True,

1492

backup_files=not no_backup,

1493

file_list=file_list)

1293

ignore_zero=True)

1494

1294

1495

1295

1496

1296

class cmd_assert_fail(Command):

1512

1312

help.help(topic)

1513

1313

1514

1314

1315

class cmd_update_stat_cache(Command):

1316

"""Update stat-cache mapping inodes to SHA-1 hashes.

1317

1318

For testing only."""

1319

hidden = True

1320

def run(self):

1321

from bzrlib.statcache import update_cache

1322

b = find_branch('.')

1323

update_cache(b.base, b.read_working_inventory())

1324

1515

1325

1516

1326

1517

1327

class cmd_plugins(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

1551

1354

'verbose': None,

1552

1355

'version': None,

1553

1356

'email': None,

1554

'unchanged': None,

1555

1357

'update': None,

1556

1358

'long': None,

1557

1359

'root': str,

1558

'no-backup': None,

1559

'merge-type': get_merge_type,

1560

1360

}

1561

1361

1562

1362

SHORT_OPTIONS = {

1586

1386

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

1587

1387

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

1588

1388

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

1589

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

1590

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

1389

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

1390

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

1591

1391

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

1592

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

1392

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

1593

1393

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

1594

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

1595

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

1394

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

1395

Traceback (most recent call last):

1396

...

1397

ValueError: invalid literal for int(): v500

1596

1398

"""

1597

1399

args = []

1598

1400

opts = {}

1712

1514

return argdict

1713

1515

1714

1516

1517

def _parse_master_args(argv):

1518

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

1519

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

1520

1521

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

1522

and ones that come *after* the command.

1523

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

1524

And are generally applied before plugins are loaded.

1525

1526

The current list are:

1527

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

1528

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

1529

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

1530

behavior.

1531

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

1532

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

1533

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

1534

This is also a non-master option.

1535

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

1536

1537

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

1538

Traceback (most recent call last):

1539

...

1540

BzrCommandError: Invalid master option: 'test'

1541

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

1542

>>> print argv

1543

['command']

1544

>>> print opts['version']

1545

True

1546

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

1547

>>> print argv

1548

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

1549

>>> print opts['profile']

1550

True

1551

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

1552

>>> print argv

1553

['command']

1554

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

1555

True

1556

>>> print opts['profile']

1557

False

1558

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

1559

>>> print argv

1560

['command', '--profile']

1561

>>> print opts['profile']

1562

False

1563

"""

1564

master_opts = {'builtin':False,

1565

'no-plugins':False,

1566

'version':False,

1567

'profile':False,

1568

'help':False

1569

}

1570

1571

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

1572

# what front-end is supposed to be run

1573

# For now, we are just ignoring it.

1574

cmd_name = argv.pop(0)

1575

for arg in argv[:]:

1576

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

1577

break

1578

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

1579

if arg not in master_opts:

1580

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

1581

# just let it be handled by the main section instead

1582

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

1583

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

1584

master_opts[arg] = True

1585

return argv, master_opts

1586

1587

1715

1588

1716

1589

def run_bzr(argv):

1717

1590

"""Execute a command.

1718

1591

1719

1592

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

1720

1593

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

1594

"""

1740

1741

1595

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

1596

1778

if not args:

1779

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

1597

try:

1598

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

1599

argv, master_opts = _parse_master_args(argv)

1600

if not master_opts['no-plugins']:

1601

from bzrlib.plugin import load_plugins

1602

load_plugins()

1603

1604

args, opts = parse_args(argv)

1605

1606

if master_opts['help']:

1607

from bzrlib.help import help

1608

if argv:

1609

help(argv[0])

1610

else:

1611

help()

1612

return 0

1613

1614

if 'help' in opts:

1615

from bzrlib.help import help

1616

if args:

1617

help(args[0])

1618

else:

1619

help()

1620

return 0

1621

elif 'version' in opts:

1622

show_version()

1623

return 0

1624

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

1625

include_plugins=False

1626

args = args[1:]

1627

cmd = str(args.pop(0))

1628

except IndexError:

1629

import help

1630

help.help()

1780

1631

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)

1632

1633

1634

plugins_override = not (master_opts['builtin'])

1635

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

1636

1637

profile = master_opts['profile']

1638

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

1639

# master/global option

1640

if 'profile' in opts:

1641

profile = True

1642

del opts['profile']

1786

1643

1787

1644

# check options are reasonable

1788

1645

allowed = cmd_class.takes_options

1797

1654

for k, v in opts.items():

1798

1655

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

1799

1656

1800

if opt_profile:

1657

if profile:

1801

1658

import hotshot, tempfile

1802

1659

pffileno, pfname = tempfile.mkstemp()

1803

1660

try:

1824

1681

1825

1682

def _report_exception(summary, quiet=False):

1826

1683

import traceback

1827

1828

1684

log_error('bzr: ' + summary)

1829

1685

bzrlib.trace.log_exception()

1830

1686

1831

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

1832

traceback.print_exc()

1833

1834

1687

if not quiet:

1835

sys.stderr.write('\n')

1836

1688

tb = sys.exc_info()[2]

1837

1689

exinfo = traceback.extract_tb(tb)

1838

1690

if exinfo:

1848

1700

try:

1849

1701

try:

1850

1702

try:

1851

return run_bzr(argv[1:])

1703

return run_bzr(argv)

1852

1704

finally:

1853

1705

# do this here inside the exception wrappers to catch EPIPE

1854

1706

sys.stdout.flush()

1855

1707

except BzrError, e:

1856

1708

quiet = isinstance(e, (BzrCommandError))

1857

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

1709

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

1858

1710

if len(e.args) > 1:

1859

1711

for h in e.args[1]:

1860

1712

# some explanation or hints