~bzr-pqm/bzr/bzr.dev : revision 779

16

17

18

19

import sys, os, time, os.path

20

from sets import Set

19

import sys, os

21

20

22

21

import bzrlib

23

22

from bzrlib.trace import mutter, note, log_error

24

from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError

25

from bzrlib.osutils import quotefn, pumpfile, isdir, isfile

26

from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree

27

from bzrlib.revision import Revision

28

from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \

23

from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError

24

from bzrlib.osutils import quotefn

25

from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \

29

26

format_date

30

27

31

28

29

plugin_cmds = {}

30

31

32

def register_command(cmd):

33

"Utility function to help register a command"

34

global plugin_cmds

35

k = cmd.__name__

36

if k.startswith("cmd_"):

37

k_unsquished = _unsquish_command_name(k)

38

else:

39

k_unsquished = k

40

if not plugin_cmds.has_key(k_unsquished):

41

plugin_cmds[k_unsquished] = cmd

42

else:

43

log_error('Two plugins defined the same command: %r' % k)

44

log_error('Not loading the one in %r' % sys.modules[cmd.__module__])

45

46

32

47

def _squish_command_name(cmd):

33

48

return 'cmd_' + cmd.replace('-', '_')

34

49

37

52

assert cmd.startswith("cmd_")

38

53

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

39

54

40

def get_all_cmds():

41

"""Return canonical name and class for all registered commands."""

55

def _parse_revision_str(revstr):

56

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

57

58

There are several possibilities:

59

60

'234' -> 234

61

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

62

':234' -> [None, 234]

63

'234:' -> [234, None]

64

65

In the future we will also support:

66

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

67

'hash:blahblahblah' -> ?

68

potentially:

69

'tag:mytag' -> ?

70

"""

71

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

72

revs = revstr.split(':')

73

if len(revs) > 2:

74

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

75

76

if not revs[0]:

77

revs[0] = None

78

else:

79

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

80

81

if not revs[1]:

82

revs[1] = None

83

else:

84

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

85

else:

86

revs = int(revstr)

87

return revs

88

89

90

91

def _get_cmd_dict(plugins_override=True):

92

d = {}

42

93

for k, v in globals().iteritems():

43

94

if k.startswith("cmd_"):

44

yield _unsquish_command_name(k), v

45

46

def get_cmd_class(cmd):

95

d[_unsquish_command_name(k)] = v

96

# If we didn't load plugins, the plugin_cmds dict will be empty

97

if plugins_override:

98

d.update(plugin_cmds)

99

else:

100

d2 = plugin_cmds.copy()

101

d2.update(d)

102

d = d2

103

return d

104

105

106

def get_all_cmds(plugins_override=True):

107

"""Return canonical name and class for all registered commands."""

108

for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():

109

yield k,v

110

111

112

def get_cmd_class(cmd, plugins_override=True):

47

113

"""Return the canonical name and command class for a command.

48

114

"""

49

115

cmd = str(cmd) # not unicode

50

116

51

117

# first look up this command under the specified name

118

cmds = _get_cmd_dict(plugins_override=plugins_override)

52

119

try:

53

return cmd, globals()[_squish_command_name(cmd)]

120

return cmd, cmds[cmd]

54

121

except KeyError:

55

122

pass

56

123

57

124

# look for any command which claims this as an alias

58

for cmdname, cmdclass in get_all_cmds():

125

for cmdname, cmdclass in cmds.iteritems():

59

126

if cmd in cmdclass.aliases:

60

127

return cmdname, cmdclass

61

128

66

133

raise BzrCommandError("unknown command %r" % cmd)

67

134

68

135

69

class Command:

136

class Command(object):

70

137

"""Base class for commands.

71

138

72

139

The docstring for an actual command should give a single-line

131

198

"""

132

199

133

200

def find_command(cls, cmd):

201

import os.path

134

202

bzrpath = os.environ.get('BZRPATH', '')

135

203

136

for dir in bzrpath.split(':'):

204

for dir in bzrpath.split(os.pathsep):

137

205

path = os.path.join(dir, cmd)

138

206

if os.path.isfile(path):

139

207

return ExternalCommand(path)

145

213

def __init__(self, path):

146

214

self.path = path

147

215

148

# TODO: If either of these fail, we should detect that and

149

# assume that path is not really a bzr plugin after all.

150

151

216

pipe = os.popen('%s --bzr-usage' % path, 'r')

152

217

self.takes_options = pipe.readline().split()

218

219

for opt in self.takes_options:

220

if not opt in OPTIONS:

221

raise BzrError("Unknown option '%s' returned by external command %s"

222

% (opt, path))

223

224

# TODO: Is there any way to check takes_args is valid here?

153

225

self.takes_args = pipe.readline().split()

154

pipe.close()

226

227

if pipe.close() is not None:

228

raise BzrError("Failed funning '%s --bzr-usage'" % path)

155

229

156

230

pipe = os.popen('%s --bzr-help' % path, 'r')

157

231

self.__doc__ = pipe.read()

158

pipe.close()

232

if pipe.close() is not None:

233

raise BzrError("Failed funning '%s --bzr-help'" % path)

159

234

160

235

def __call__(self, options, arguments):

161

236

Command.__init__(self, options, arguments)

168

243

keys = kargs.keys()

169

244

keys.sort()

170

245

for name in keys:

246

optname = name.replace('_','-')

171

247

value = kargs[name]

172

if OPTIONS.has_key(name):

248

if OPTIONS.has_key(optname):

173

249

# it's an option

174

opts.append('--%s' % name)

250

opts.append('--%s' % optname)

175

251

if value is not None and value is not True:

176

252

opts.append(str(value))

177

253

else:

189

265

class cmd_status(Command):

190

266

"""Display status summary.

191

267

192

For each file there is a single line giving its file state and name.

193

The name is that in the current revision unless it is deleted or

194

missing, in which case the old name is shown.

268

This reports on versioned and unknown files, reporting them

269

grouped by state. Possible states are:

270

271

added

272

Versioned in the working copy but not in the previous revision.

273

274

removed

275

Versioned in the previous revision but removed or deleted

276

in the working copy.

277

278

renamed

279

Path of this file changed from the previous revision;

280

the text may also have changed. This includes files whose

281

parent directory was renamed.

282

283

modified

284

Text has changed since the previous revision.

285

286

unchanged

287

Nothing about this file has changed since the previous revision.

288

Only shown with --all.

289

290

unknown

291

Not versioned and not matching an ignore pattern.

292

293

To see ignored files use 'bzr ignored'. For details in the

294

changes to file texts, use 'bzr diff'.

295

296

If no arguments are specified, the status of the entire working

297

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

298

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

299

is reported for everything inside that directory.

195

300

"""

196

301

takes_args = ['file*']

197

takes_options = ['all']

302

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

198

303

aliases = ['st', 'stat']

199

304

200

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

201

b = Branch('.', lock_mode='r')

202

b.show_status(show_all=all, file_list=file_list)

305

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

306

if file_list:

307

b = Branch(file_list[0])

308

file_list = [b.relpath(x) for x in file_list]

309

# special case: only one path was given and it's the root

310

# of the branch

311

if file_list == ['']:

312

file_list = None

313

else:

314

b = Branch('.')

315

import status

316

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

317

specific_files=file_list)

203

318

204

319

205

320

class cmd_cat_revision(Command):

242

357

recursively add that parent, rather than giving an error?

243

358

"""

244

359

takes_args = ['file+']

245

takes_options = ['verbose']

360

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

246

361

247

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

248

bzrlib.add.smart_add(file_list, verbose)

362

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

363

bzrlib.add.smart_add(file_list, verbose, not no_recurse)

364

365

366

367

class cmd_mkdir(Command):

368

"""Create a new versioned directory.

369

370

This is equivalent to creating the directory and then adding it.

371

"""

372

takes_args = ['dir+']

373

374

def run(self, dir_list):

375

import os

376

import bzrlib.branch

377

378

b = None

379

380

for d in dir_list:

381

os.mkdir(d)

382

if not b:

383

b = bzrlib.branch.Branch(d)

384

b.add([d], verbose=True)

249

385

250

386

251

387

class cmd_relpath(Command):

252

388

"""Show path of a file relative to root"""

253

389

takes_args = ['filename']

390

hidden = True

254

391

255

392

def run(self, filename):

256

393

print Branch(filename).relpath(filename)

259

396

260

397

class cmd_inventory(Command):

261

398

"""Show inventory of the current working copy or a revision."""

262

takes_options = ['revision']

399

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

263

400

264

def run(self, revision=None):

401

def run(self, revision=None, show_ids=False):

265

402

b = Branch('.')

266

403

if revision == None:

267

404

inv = b.read_working_inventory()

268

405

else:

269

406

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

270

407

271

for path, entry in inv.iter_entries():

272

print '%-50s %s' % (entry.file_id, path)

408

for path, entry in inv.entries():

409

if show_ids:

410

print '%-50s %s' % (path, entry.file_id)

411

else:

412

print path

273

413

274

414

275

415

class cmd_move(Command):

309

449

310

450

311

451

452

453

454

class cmd_pull(Command):

455

"""Pull any changes from another branch into the current one.

456

457

If the location is omitted, the last-used location will be used.

458

Both the revision history and the working directory will be

459

updated.

460

461

This command only works on branches that have not diverged. Branches are

462

considered diverged if both branches have had commits without first

463

pulling from the other.

464

465

If branches have diverged, you can use 'bzr merge' to pull the text changes

466

from one into the other.

467

"""

468

takes_args = ['location?']

469

470

def run(self, location=None):

471

from bzrlib.merge import merge

472

import errno

473

474

br_to = Branch('.')

475

stored_loc = None

476

try:

477

stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')

478

except IOError, e:

479

if errno == errno.ENOENT:

480

raise

481

if location is None:

482

if stored_loc is None:

483

raise BzrCommandError("No pull location known or specified.")

484

else:

485

print "Using last location: %s" % stored_loc

486

location = stored_loc

487

from branch import find_branch, DivergedBranches

488

br_from = find_branch(location)

489

location = pull_loc(br_from)

490

old_revno = br_to.revno()

491

try:

492

br_to.update_revisions(br_from)

493

except DivergedBranches:

494

raise BzrCommandError("These branches have diverged. Try merge.")

495

496

merge(('.', -1), ('.', old_revno), check_clean=False)

497

if location != stored_loc:

498

br_to.controlfile("x-pull", "wb").write(location + "\n")

499

500

501

502

class cmd_branch(Command):

503

"""Create a new copy of a branch.

504

505

If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will

506

be used. In other words, "branch ../foo/bar" will attempt to create ./bar.

507

508

To retrieve the branch as of a particular revision, supply the --revision

509

parameter, as in "branch foo/bar -r 5".

510

"""

511

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

512

takes_options = ['revision']

513

514

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

515

import errno

516

from bzrlib.merge import merge

517

from branch import find_branch, DivergedBranches, NoSuchRevision

518

from shutil import rmtree

519

try:

520

br_from = find_branch(from_location)

521

except OSError, e:

522

if e.errno == errno.ENOENT:

523

raise BzrCommandError('Source location "%s" does not exist.' %

524

to_location)

525

else:

526

raise

527

528

if to_location is None:

529

to_location = os.path.basename(from_location.rstrip("/\\"))

530

531

try:

532

os.mkdir(to_location)

533

except OSError, e:

534

if e.errno == errno.EEXIST:

535

raise BzrCommandError('Target directory "%s" already exists.' %

536

to_location)

537

if e.errno == errno.ENOENT:

538

raise BzrCommandError('Parent of "%s" does not exist.' %

539

to_location)

540

else:

541

raise

542

br_to = Branch(to_location, init=True)

543

544

try:

545

br_to.update_revisions(br_from, stop_revision=revision)

546

except NoSuchRevision:

547

rmtree(to_location)

548

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

549

revision)

550

raise BzrCommandError(msg)

551

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

552

check_clean=False, ignore_zero=True)

553

from_location = pull_loc(br_from)

554

br_to.controlfile("x-pull", "wb").write(from_location + "\n")

555

556

557

def pull_loc(branch):

558

# TODO: Should perhaps just make attribute be 'base' in

559

# RemoteBranch and Branch?

560

if hasattr(branch, "baseurl"):

561

return branch.baseurl

562

else:

563

return branch.base

564

565

566

312

567

class cmd_renames(Command):

313

568

"""Show list of renamed files.

314

569

330

585

331

586

332

587

class cmd_info(Command):

333

"""Show statistical information for this branch"""

334

def run(self):

588

"""Show statistical information about a branch."""

589

takes_args = ['branch?']

590

591

def run(self, branch=None):

335

592

import info

336

info.show_info(Branch('.'))

593

594

from branch import find_branch

595

b = find_branch(branch)

596

info.show_info(b)

337

597

338

598

339

599

class cmd_remove(Command):

363

623

b = Branch(filename)

364

624

i = b.inventory.path2id(b.relpath(filename))

365

625

if i == None:

366

bailout("%r is not a versioned file" % filename)

626

raise BzrError("%r is not a versioned file" % filename)

367

627

else:

368

628

print i

369

629

380

640

inv = b.inventory

381

641

fid = inv.path2id(b.relpath(filename))

382

642

if fid == None:

383

bailout("%r is not a versioned file" % filename)

643

raise BzrError("%r is not a versioned file" % filename)

384

644

for fip in inv.get_idpath(fid):

385

645

print fip

386

646

387

647

388

648

class cmd_revision_history(Command):

389

649

"""Display list of revision ids on this branch."""

650

hidden = True

390

651

def run(self):

391

652

for patchid in Branch('.').revision_history():

392

653

print patchid

444

705

"""

445

706

446

707

takes_args = ['file*']

447

takes_options = ['revision']

448

aliases = ['di']

708

takes_options = ['revision', 'diff-options']

709

aliases = ['di', 'dif']

449

710

450

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

711

def run(self, revision=None, file_list=None, diff_options=None):

451

712

from bzrlib.diff import show_diff

713

from bzrlib import find_branch

714

715

if file_list:

716

b = find_branch(file_list[0])

717

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

718

if file_list == ['']:

719

# just pointing to top-of-tree

720

file_list = None

721

else:

722

b = Branch('.')

452

723

453

show_diff(Branch('.'), revision, file_list)

724

show_diff(b, revision, specific_files=file_list,

725

external_diff_options=diff_options)

726

727

728

454

729

455

730

456

731

class cmd_deleted(Command):

475

750

else:

476

751

print path

477

752

753

754

class cmd_modified(Command):

755

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

756

hidden = True

757

def run(self):

758

import statcache

759

b = Branch('.')

760

inv = b.read_working_inventory()

761

sc = statcache.update_cache(b, inv)

762

basis = b.basis_tree()

763

basis_inv = basis.inventory

764

765

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

766

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

767

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

768

# calculate paths as necessary.

769

770

for file_id in basis_inv:

771

cacheentry = sc.get(file_id)

772

if not cacheentry: # deleted

773

continue

774

ie = basis_inv[file_id]

775

if cacheentry[statcache.SC_SHA1] != ie.text_sha1:

776

path = inv.id2path(file_id)

777

print path

778

779

780

781

class cmd_added(Command):

782

"""List files added in working tree."""

783

hidden = True

784

def run(self):

785

b = Branch('.')

786

wt = b.working_tree()

787

basis_inv = b.basis_tree().inventory

788

inv = wt.inventory

789

for file_id in inv:

790

if file_id in basis_inv:

791

continue

792

path = inv.id2path(file_id)

793

if not os.access(b.abspath(path), os.F_OK):

794

continue

795

print path

796

797

798

478

799

class cmd_root(Command):

479

800

"""Show the tree root directory.

480

801

491

812

class cmd_log(Command):

492

813

"""Show log of this branch.

493

814

494

TODO: Option to limit range.

815

To request a range of logs, you can use the command -r begin:end

816

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

817

also valid.

495

818

496

TODO: Perhaps show most-recent first with an option for last.

819

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

820

497

821

"""

822

498

823

takes_args = ['filename?']

499

takes_options = ['timezone', 'verbose', 'show-ids']

500

def run(self, filename=None, timezone='original', verbose=False, show_ids=False):

501

from branch import find_branch

502

b = find_branch((filename or '.'), lock_mode='r')

824

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

825

826

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

827

verbose=False,

828

show_ids=False,

829

forward=False,

830

revision=None):

831

from bzrlib import show_log, find_branch

832

import codecs

833

834

direction = (forward and 'forward') or 'reverse'

835

503

836

if filename:

504

filename = b.relpath(filename)

505

bzrlib.show_log(b, filename,

506

show_timezone=timezone,

507

verbose=verbose,

508

show_ids=show_ids)

837

b = find_branch(filename)

838

fp = b.relpath(filename)

839

if fp:

840

file_id = b.read_working_inventory().path2id(fp)

841

else:

842

file_id = None # points to branch root

843

else:

844

b = find_branch('.')

845

file_id = None

846

847

if revision == None:

848

revision = [None, None]

849

elif isinstance(revision, int):

850

revision = [revision, revision]

851

else:

852

# pair of revisions?

853

pass

854

855

assert len(revision) == 2

856

857

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

858

859

# use 'replace' so that we don't abort if trying to write out

860

# in e.g. the default C locale.

861

outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')

862

863

show_log(b, file_id,

864

show_timezone=timezone,

865

verbose=verbose,

866

show_ids=show_ids,

867

to_file=outf,

868

direction=direction,

869

start_revision=revision[0],

870

end_revision=revision[1])

509

871

510

872

511

873

512

874

class cmd_touching_revisions(Command):

513

"""Return revision-ids which affected a particular file."""

875

"""Return revision-ids which affected a particular file.

876

877

A more user-friendly interface is "bzr log FILE"."""

514

878

hidden = True

515

879

takes_args = ["filename"]

516

880

def run(self, filename):

517

b = Branch(filename, lock_mode='r')

881

b = Branch(filename)

518

882

inv = b.read_working_inventory()

519

883

file_id = inv.path2id(b.relpath(filename))

520

884

for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):

550

914

551

915

552

916

class cmd_unknowns(Command):

553

"""List unknown files"""

917

"""List unknown files."""

554

918

def run(self):

555

919

for f in Branch('.').unknowns():

556

920

print quotefn(f)

558

922

559

923

560

924

class cmd_ignore(Command):

561

"""Ignore a command or pattern

925

"""Ignore a command or pattern.

562

926

563

927

To remove patterns from the ignore list, edit the .bzrignore file.

564

928

578

942

579

943

def run(self, name_pattern):

580

944

from bzrlib.atomicfile import AtomicFile

581

import codecs

945

import os.path

582

946

583

947

b = Branch('.')

584

948

ifn = b.abspath('.bzrignore')

585

949

586

# FIXME: probably doesn't handle non-ascii patterns

587

588

950

if os.path.exists(ifn):

589

f = b.controlfile(ifn, 'rt')

590

igns = f.read()

591

f.close()

951

f = open(ifn, 'rt')

952

try:

953

igns = f.read().decode('utf-8')

954

finally:

955

f.close()

592

956

else:

593

957

igns = ''

594

958

959

# TODO: If the file already uses crlf-style termination, maybe

960

# we should use that for the newly added lines?

961

595

962

if igns and igns[-1] != '\n':

596

963

igns += '\n'

597

964

igns += name_pattern + '\n'

598

965

599

f = AtomicFile(ifn, 'wt')

600

f.write(igns)

601

f.commit()

966

try:

967

f = AtomicFile(ifn, 'wt')

968

f.write(igns.encode('utf-8'))

969

f.commit()

970

finally:

971

f.close()

602

972

603

973

inv = b.working_tree().inventory

604

974

if inv.path2id('.bzrignore'):

644

1014

class cmd_export(Command):

645

1015

"""Export past revision to destination directory.

646

1016

647

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

1017

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

1018

1019

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

1020

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

1021

# TODO: list known exporters

648

1022

takes_args = ['dest']

649

takes_options = ['revision']

650

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

1023

takes_options = ['revision', 'format']

1024

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

651

1025

b = Branch('.')

652

1026

if revision == None:

653

1027

rh = b.revision_history()[-1]

654

1028

else:

655

1029

rh = b.lookup_revision(int(revision))

656

1030

t = b.revision_tree(rh)

657

t.export(dest)

1031

t.export(dest, format)

658

1032

659

1033

660

1034

class cmd_cat(Command):

681

1055

class cmd_commit(Command):

682

1056

"""Commit changes into a new revision.

683

1057

684

TODO: Commit only selected files.

1058

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

1059

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

1060

committed.

1061

1062

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

1063

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

1064

newly-added directory that is not itself committed.

685

1065

686

1066

TODO: Run hooks on tree to-be-committed, and after commit.

687

1067

688

1068

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

689

1069

"""

1070

takes_args = ['selected*']

690

1071

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

691

1072

aliases = ['ci', 'checkin']

692

1073

693

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

1074

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

1075

from bzrlib.commit import commit

1076

from bzrlib.osutils import get_text_message

1077

694

1078

## Warning: shadows builtin file()

695

1079

if not message and not file:

696

raise BzrCommandError("please specify a commit message",

697

["use either --message or --file"])

1080

import cStringIO

1081

stdout = sys.stdout

1082

catcher = cStringIO.StringIO()

1083

sys.stdout = catcher

1084

cmd_status({"file_list":selected_list}, {})

1085

info = catcher.getvalue()

1086

sys.stdout = stdout

1087

message = get_text_message(info)

1088

1089

if message is None:

1090

raise BzrCommandError("please specify a commit message",

1091

["use either --message or --file"])

698

1092

elif message and file:

699

1093

raise BzrCommandError("please specify either --message or --file")

700

1094

702

1096

import codecs

703

1097

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

704

1098

705

Branch('.').commit(message, verbose=verbose)

1099

b = Branch('.')

1100

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

706

1101

707

1102

708

1103

class cmd_check(Command):

710

1105

711

1106

This command checks various invariants about the branch storage to

712

1107

detect data corruption or bzr bugs.

1108

1109

If given the --update flag, it will update some optional fields

1110

to help ensure data consistency.

713

1111

"""

714

1112

takes_args = ['dir?']

1113

715

1114

def run(self, dir='.'):

716

1115

import bzrlib.check

717

bzrlib.check.check(Branch(dir, find_root=False))

1116

bzrlib.check.check(Branch(dir))

1117

1118

1119

1120

class cmd_upgrade(Command):

1121

"""Upgrade branch storage to current format.

1122

1123

This should normally be used only after the check command tells

1124

you to run it.

1125

"""

1126

takes_args = ['dir?']

1127

1128

def run(self, dir='.'):

1129

from bzrlib.upgrade import upgrade

1130

upgrade(Branch(dir))

718

1131

719

1132

720

1133

733

1146

"""Run internal test suite"""

734

1147

hidden = True

735

1148

def run(self):

736

failures, tests = 0, 0

737

738

import doctest, bzrlib.store, bzrlib.tests

739

bzrlib.trace.verbose = False

740

741

for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \

742

bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:

743

mf, mt = doctest.testmod(m)

744

failures += mf

745

tests += mt

746

print '%-40s %3d tests' % (m.__name__, mt),

747

if mf:

748

print '%3d FAILED!' % mf

749

else:

750

print

751

752

print '%-40s %3d tests' % ('total', tests),

753

if failures:

754

print '%3d FAILED!' % failures

755

else:

756

print

757

1149

from bzrlib.selftest import selftest

1150

return int(not selftest())

758

1151

759

1152

760

1153

class cmd_version(Command):

761

"""Show version of bzr"""

1154

"""Show version of bzr."""

762

1155

def run(self):

763

1156

show_version()

764

1157

765

1158

def show_version():

766

1159

print "bzr (bazaar-ng) %s" % bzrlib.__version__

1160

# is bzrlib itself in a branch?

1161

bzrrev = bzrlib.get_bzr_revision()

1162

if bzrrev:

1163

print " (bzr checkout, revision %d {%s})" % bzrrev

767

1164

print bzrlib.__copyright__

768

1165

print "http://bazaar-ng.org/"

769

1166

print

778

1175

def run(self):

779

1176

print "it sure does!"

780

1177

1178

def parse_spec(spec):

1179

"""

1180

>>> parse_spec(None)

1181

[None, None]

1182

>>> parse_spec("./")

1183

['./', None]

1184

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

1185

['..', -1]

1186

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

1187

['../f', 35]

1188

"""

1189

if spec is None:

1190

return [None, None]

1191

if '/@' in spec:

1192

parsed = spec.split('/@')

1193

assert len(parsed) == 2

1194

if parsed[1] == "":

1195

parsed[1] = -1

1196

else:

1197

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

1198

assert parsed[1] >=0

1199

else:

1200

parsed = [spec, None]

1201

return parsed

1202

1203

1204

1205

class cmd_merge(Command):

1206

"""Perform a three-way merge of trees.

1207

1208

The SPEC parameters are working tree or revision specifiers. Working trees

1209

are specified using standard paths or urls. No component of a directory

1210

path may begin with '@'.

1211

1212

Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'

1213

1214

Revisions are specified using a dirname/@revno pair, where dirname is the

1215

branch directory and revno is the revision within that branch. If no revno

1216

is specified, the latest revision is used.

1217

1218

Revision examples: './@127', 'foo/@', '../@1'

1219

1220

The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is

1221

not supplied, the common ancestor of OTHER_SPEC the current branch is used

1222

as the BASE.

1223

1224

merge refuses to run if there are any uncommitted changes, unless

1225

--force is given.

1226

"""

1227

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

1228

takes_options = ['force']

1229

1230

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

1231

from bzrlib.merge import merge

1232

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

1233

check_clean=(not force))

1234

1235

1236

1237

class cmd_simple_revert(Command):

1238

"""Restore selected files from a previous revision.

1239

"""

1240

takes_args = ['file+']

1241

def run(self, file_list):

1242

if not file_list:

1243

file_list = ['.']

1244

1245

b = find_branch(file_list[0])

1246

1247

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

1248

1249

1250

class cmd_revert(Command):

1251

"""Reverse all changes since the last commit.

1252

1253

Only versioned files are affected.

1254

1255

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

1256

that the revert can be undone.

1257

"""

1258

takes_options = ['revision']

1259

1260

def run(self, revision=-1):

1261

from bzrlib.merge import merge

1262

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

1263

check_clean=False,

1264

ignore_zero=True)

1265

781

1266

782

1267

class cmd_assert_fail(Command):

783

1268

"""Test reporting of assertion failures"""

806

1291

def run(self):

807

1292

import statcache

808

1293

b = Branch('.')

809

inv = b.read_working_inventory()

810

statcache.update_cache(b, inv)

811

812

813

######################################################################

814

# main routine

1294

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

1295

1296

1297

1298

class cmd_plugins(Command):

1299

"""List plugins"""

1300

hidden = True

1301

def run(self):

1302

import bzrlib.plugin

1303

from pprint import pprint

1304

pprint(bzrlib.plugin.all_plugins)

1305

815

1306

816

1307

817

1308

# list of all available options; the rhs can be either None for an

819

1310

# the type.

820

1311

OPTIONS = {

821

1312

'all': None,

1313

'diff-options': str,

822

1314

'help': None,

823

1315

'file': unicode,

1316

'force': None,

1317

'format': unicode,

1318

'forward': None,

824

1319

'message': unicode,

1320

'no-recurse': None,

825

1321

'profile': None,

826

'revision': int,

1322

'revision': _parse_revision_str,

827

1323

'show-ids': None,

828

1324

'timezone': str,

829

1325

'verbose': None,

830

1326

'version': None,

831

1327

'email': None,

1328

'update': None,

832

1329

}

833

1330

834

1331

SHORT_OPTIONS = {

1332

'F': 'file',

1333

'h': 'help',

835

1334

'm': 'message',

836

'F': 'file',

837

1335

'r': 'revision',

838

1336

'v': 'verbose',

839

1337

}

855

1353

(['status'], {'all': True})

856

1354

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

857

1355

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

1356

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

1357

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

1358

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

1359

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

1360

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

1361

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

1362

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

1363

Traceback (most recent call last):

1364

...

1365

ValueError: invalid literal for int(): v500

858

1366

"""

859

1367

args = []

860

1368

opts = {}

874

1382

else:

875

1383

optname = a[2:]

876

1384

if optname not in OPTIONS:

877

bailout('unknown long option %r' % a)

1385

raise BzrError('unknown long option %r' % a)

878

1386

else:

879

1387

shortopt = a[1:]

880

if shortopt not in SHORT_OPTIONS:

881

bailout('unknown short option %r' % a)

882

optname = SHORT_OPTIONS[shortopt]

1388

if shortopt in SHORT_OPTIONS:

1389

# Multi-character options must have a space to delimit

1390

# their value

1391

optname = SHORT_OPTIONS[shortopt]

1392

else:

1393

# Single character short options, can be chained,

1394

# and have their value appended to their name

1395

shortopt = a[1:2]

1396

if shortopt not in SHORT_OPTIONS:

1397

# We didn't find the multi-character name, and we

1398

# didn't find the single char name

1399

raise BzrError('unknown short option %r' % a)

1400

optname = SHORT_OPTIONS[shortopt]

1401

1402

if a[2:]:

1403

# There are extra things on this option

1404

# see if it is the value, or if it is another

1405

# short option

1406

optargfn = OPTIONS[optname]

1407

if optargfn is None:

1408

# This option does not take an argument, so the

1409

# next entry is another short option, pack it back

1410

# into the list

1411

argv.insert(0, '-' + a[2:])

1412

else:

1413

# This option takes an argument, so pack it

1414

# into the array

1415

optarg = a[2:]

883

1416

884

1417

if optname in opts:

885

1418

# XXX: Do we ever want to support this, e.g. for -r?

886

bailout('repeated option %r' % a)

1419

raise BzrError('repeated option %r' % a)

887

1420

888

1421

optargfn = OPTIONS[optname]

889

1422

if optargfn:

890

1423

if optarg == None:

891

1424

if not argv:

892

bailout('option %r needs an argument' % a)

1425

raise BzrError('option %r needs an argument' % a)

893

1426

else:

894

1427

optarg = argv.pop(0)

895

1428

opts[optname] = optargfn(optarg)

896

1429

else:

897

1430

if optarg != None:

898

bailout('option %r takes no argument' % optname)

1431

raise BzrError('option %r takes no argument' % optname)

899

1432

opts[optname] = True

900

1433

else:

901

1434

args.append(a)

949

1482

return argdict

950

1483

951

1484

1485

def _parse_master_args(argv):

1486

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

1487

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

1488

1489

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

1490

and ones that come *after* the command.

1491

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

1492

And are generally applied before plugins are loaded.

1493

1494

The current list are:

1495

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

1496

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

1497

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

1498

behavior.

1499

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

1500

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

1501

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

1502

This is also a non-master option.

1503

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

1504

1505

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

1506

Traceback (most recent call last):

1507

...

1508

BzrCommandError: Invalid master option: 'test'

1509

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

1510

>>> print argv

1511

['command']

1512

>>> print opts['version']

1513

True

1514

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

1515

>>> print argv

1516

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

1517

>>> print opts['profile']

1518

True

1519

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

1520

>>> print argv

1521

['command']

1522

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

1523

True

1524

>>> print opts['profile']

1525

False

1526

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

1527

>>> print argv

1528

['command', '--profile']

1529

>>> print opts['profile']

1530

False

1531

"""

1532

master_opts = {'builtin':False,

1533

'no-plugins':False,

1534

'version':False,

1535

'profile':False,

1536

'help':False

1537

}

1538

1539

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

1540

# what front-end is supposed to be run

1541

# For now, we are just ignoring it.

1542

cmd_name = argv.pop(0)

1543

for arg in argv[:]:

1544

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

1545

break

1546

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

1547

if arg not in master_opts:

1548

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

1549

# just let it be handled by the main section instead

1550

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

1551

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

1552

master_opts[arg] = True

1553

return argv, master_opts

1554

1555

952

1556

953

1557

def run_bzr(argv):

954

1558

"""Execute a command.

959

1563

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

960

1564

961

1565

try:

962

args, opts = parse_args(argv[1:])

1566

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

1567

argv, master_opts = _parse_master_args(argv)

1568

if not master_opts['no-plugins']:

1569

bzrlib.load_plugins()

1570

1571

args, opts = parse_args(argv)

1572

1573

if master_opts['help']:

1574

from bzrlib.help import help

1575

if argv:

1576

help(argv[0])

1577

else:

1578

help()

1579

return 0

1580

963

1581

if 'help' in opts:

964

import help

1582

from bzrlib.help import help

965

1583

if args:

966

help.help(args[0])

1584

help(args[0])

967

1585

else:

968

help.help()

1586

help()

969

1587

return 0

970

1588

elif 'version' in opts:

971

1589

show_version()

972

1590

return 0

1591

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

1592

include_plugins=False

1593

args = args[1:]

973

1594

cmd = str(args.pop(0))

974

1595

except IndexError:

975

log_error('usage: bzr COMMAND')

976

log_error(' try "bzr help"')

1596

import help

1597

help.help()

977

1598

return 1

978

979

canonical_cmd, cmd_class = get_cmd_class(cmd)

980

981

# global option

1599

1600

1601

plugins_override = not (master_opts['builtin'])

1602

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

1603

1604

profile = master_opts['profile']

1605

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

1606

# master/global option

982

1607

if 'profile' in opts:

983

1608

profile = True

984

1609

del opts['profile']

985

else:

986

profile = False

987

1610

988

1611

# check options are reasonable

989

1612

allowed = cmd_class.takes_options

1020

1643

os.close(pffileno)

1021

1644

os.remove(pfname)

1022

1645

else:

1023

cmdobj = cmd_class(cmdopts, cmdargs).status

1646

return cmd_class(cmdopts, cmdargs).status

1024

1647

1025

1648

1026

1649

def _report_exception(summary, quiet=False):