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

16

17

18

19

import sys, os

19

import sys, os, time, os.path

20

from sets import Set

20

21

22

import bzrlib

22

23

from bzrlib.trace import mutter, note, log_error

23

24

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

24

from bzrlib.osutils import quotefn

25

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

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, \

26

29

format_date

27

30

28

31

34

37

assert cmd.startswith("cmd_")

35

38

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

36

39

37

def _parse_revision_str(revstr):

38

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

39

40

There are several possibilities:

41

42

'234' -> 234

43

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

44

':234' -> [None, 234]

45

'234:' -> [234, None]

46

47

In the future we will also support:

48

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

49

'hash:blahblahblah' -> ?

50

potentially:

51

'tag:mytag' -> ?

52

"""

53

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

54

revs = revstr.split(':')

55

if len(revs) > 2:

56

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

57

58

if not revs[0]:

59

revs[0] = None

60

else:

61

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

62

63

if not revs[1]:

64

revs[1] = None

65

else:

66

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

67

else:

68

revs = int(revstr)

69

return revs

70

71

def _find_plugins():

72

"""Find all python files which are plugins, and load their commands

73

to add to the list of "all commands"

74

75

The environment variable BZRPATH is considered a delimited set of

76

paths to look through. Each entry is searched for *.py files.

77

If a directory is found, it is also searched, but they are

78

not searched recursively. This allows you to revctl the plugins.

79

80

Inside the plugin should be a series of cmd_* function, which inherit from

81

the bzrlib.commands.Command class.

82

"""

83

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

84

85

plugin_cmds = {}

86

if not bzrpath:

87

return plugin_cmds

88

_platform_extensions = {

89

'win32':'.pyd',

90

'cygwin':'.dll',

91

'darwin':'.dylib',

92

'linux2':'.so'

93

}

94

if _platform_extensions.has_key(sys.platform):

95

platform_extension = _platform_extensions[sys.platform]

96

else:

97

platform_extension = None

98

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

99

plugin_names = {} # This should really be a set rather than a dict

100

for f in os.listdir(d):

101

if f.endswith('.py'):

102

f = f[:-3]

103

elif f.endswith('.pyc') or f.endswith('.pyo'):

104

f = f[:-4]

105

elif platform_extension and f.endswith(platform_extension):

106

f = f[:-len(platform_extension)]

107

if f.endswidth('module'):

108

f = f[:-len('module')]

109

else:

110

continue

111

if not plugin_names.has_key(f):

112

plugin_names[f] = True

113

114

plugin_names = plugin_names.keys()

115

plugin_names.sort()

116

try:

117

sys.path.insert(0, d)

118

for name in plugin_names:

119

try:

120

old_module = None

121

try:

122

if sys.modules.has_key(name):

123

old_module = sys.modules[name]

124

del sys.modules[name]

125

plugin = __import__(name, locals())

126

for k in dir(plugin):

127

if k.startswith('cmd_'):

128

k_unsquished = _unsquish_command_name(k)

129

if not plugin_cmds.has_key(k_unsquished):

130

plugin_cmds[k_unsquished] = getattr(plugin, k)

131

else:

132

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

133

log_error('Not loading the one in %r in dir %r' % (name, d))

134

finally:

135

if old_module:

136

sys.modules[name] = old_module

137

except ImportError, e:

138

log_error('Unable to load plugin: %r from %r\n%s' % (name, d, e))

139

finally:

140

sys.path.pop(0)

141

return plugin_cmds

142

143

def _get_cmd_dict(include_plugins=True):

144

d = {}

40

def get_all_cmds():

41

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

145

42

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

146

43

if k.startswith("cmd_"):

147

d[_unsquish_command_name(k)] = v

148

if include_plugins:

149

d.update(_find_plugins())

150

return d

151

152

def get_all_cmds(include_plugins=True):

153

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

154

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

155

yield k,v

156

157

158

def get_cmd_class(cmd,include_plugins=True):

44

yield _unsquish_command_name(k), v

45

46

def get_cmd_class(cmd):

159

47

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

160

48

"""

161

49

cmd = str(cmd) # not unicode

162

50

163

51

# first look up this command under the specified name

164

cmds = _get_cmd_dict(include_plugins=include_plugins)

165

52

try:

166

return cmd, cmds[cmd]

53

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

167

54

except KeyError:

168

55

pass

169

56

170

57

# look for any command which claims this as an alias

171

for cmdname, cmdclass in cmds.iteritems():

58

for cmdname, cmdclass in get_all_cmds():

172

59

if cmd in cmdclass.aliases:

173

60

return cmdname, cmdclass

174

175

cmdclass = ExternalCommand.find_command(cmd)

176

if cmdclass:

177

return cmd, cmdclass

178

179

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

180

181

182

class Command(object):

61

else:

62

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

63

64

65

class Command:

183

66

"""Base class for commands.

184

67

185

68

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

228

111

return 0

229

112

230

113

231

class ExternalCommand(Command):

232

"""Class to wrap external commands.

233

234

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

235

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

236

specified command.

237

238

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

239

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

240

our run method which is pretty straight forward.

241

242

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

243

back into command line options and arguments for the script.

244

"""

245

246

def find_command(cls, cmd):

247

import os.path

248

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

249

250

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

251

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

252

if os.path.isfile(path):

253

return ExternalCommand(path)

254

255

return None

256

257

find_command = classmethod(find_command)

258

259

def __init__(self, path):

260

self.path = path

261

262

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

263

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

264

265

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

266

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

267

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

268

pipe.close()

269

270

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

271

self.__doc__ = pipe.read()

272

pipe.close()

273

274

def __call__(self, options, arguments):

275

Command.__init__(self, options, arguments)

276

return self

277

278

def run(self, **kargs):

279

opts = []

280

args = []

281

282

keys = kargs.keys()

283

keys.sort()

284

for name in keys:

285

value = kargs[name]

286

if OPTIONS.has_key(name):

287

# it's an option

288

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

289

if value is not None and value is not True:

290

opts.append(str(value))

291

else:

292

# it's an arg, or arg list

293

if type(value) is not list:

294

value = [value]

295

for v in value:

296

if v is not None:

297

args.append(str(v))

298

299

self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)

300

return self.status

301

302

114

303

115

class cmd_status(Command):

304

116

"""Display status summary.

305

117

306

This reports on versioned and unknown files, reporting them

307

grouped by state. Possible states are:

308

309

added

310

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

311

312

removed

313

Versioned in the previous revision but removed or deleted

314

in the working copy.

315

316

renamed

317

Path of this file changed from the previous revision;

318

the text may also have changed. This includes files whose

319

parent directory was renamed.

320

321

modified

322

Text has changed since the previous revision.

323

324

unchanged

325

Nothing about this file has changed since the previous revision.

326

Only shown with --all.

327

328

unknown

329

Not versioned and not matching an ignore pattern.

330

331

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

332

changes to file texts, use 'bzr diff'.

333

334

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

335

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

336

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

337

is reported for everything inside that directory.

118

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

119

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

120

missing, in which case the old name is shown.

338

121

"""

339

takes_args = ['file*']

340

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

122

takes_options = ['all']

341

123

aliases = ['st', 'stat']

342

124

343

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

344

if file_list:

345

b = Branch(file_list[0])

346

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

347

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

348

# of the branch

349

if file_list == ['']:

350

file_list = None

351

else:

352

b = Branch('.')

353

import status

354

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

355

specific_files=file_list)

125

def run(self, all=False):

126

#import bzrlib.status

127

#bzrlib.status.tree_status(Branch('.'))

128

Branch('.').show_status(show_all=all)

356

129

357

130

358

131

class cmd_cat_revision(Command):

395

168

recursively add that parent, rather than giving an error?

396

169

"""

397

170

takes_args = ['file+']

398

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

171

takes_options = ['verbose']

399

172

400

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

401

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

402

403

404

class cmd_relpath(Command):

173

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

174

bzrlib.add.smart_add(file_list, verbose)

175

176

177

def Relpath(Command):

405

178

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

406

takes_args = ['filename']

407

hidden = True

179

takes_args = ('filename')

408

180

409

def run(self, filename):

410

print Branch(filename).relpath(filename)

181

def run(self):

182

print Branch(self.args['filename']).relpath(filename)

411

183

412

184

413

185

414

186

class cmd_inventory(Command):

415

187

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

416

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

188

takes_options = ['revision']

417

189

418

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

190

def run(self, revision=None):

419

191

b = Branch('.')

420

192

if revision == None:

421

193

inv = b.read_working_inventory()

422

194

else:

423

195

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

424

196

425

for path, entry in inv.entries():

426

if show_ids:

427

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

428

else:

429

print path

197

for path, entry in inv.iter_entries():

198

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

430

199

431

200

432

201

class cmd_move(Command):

466

235

467

236

468

237

469

470

471

class cmd_pull(Command):

472

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

473

474

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

475

Both the revision history and the working directory will be

476

updated.

477

478

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

479

considered diverged if both branches have had commits without first

480

pulling from the other.

481

482

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

483

from one into the other.

484

"""

485

takes_args = ['location?']

486

487

def run(self, location=None):

488

from bzrlib.merge import merge

489

import errno

490

491

br_to = Branch('.')

492

stored_loc = None

493

try:

494

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

495

except IOError, e:

496

if errno == errno.ENOENT:

497

raise

498

if location is None:

499

location = stored_loc

500

if location is None:

501

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

502

from branch import find_branch, DivergedBranches

503

br_from = find_branch(location)

504

location = pull_loc(br_from)

505

old_revno = br_to.revno()

506

try:

507

br_to.update_revisions(br_from)

508

except DivergedBranches:

509

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

510

511

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

512

if location != stored_loc:

513

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

514

515

516

517

class cmd_branch(Command):

518

"""Create a new copy of a branch.

519

520

If the TO_LOCATION is omitted, the last component of the

521

FROM_LOCATION will be used. In other words,

522

"branch ../foo/bar" will attempt to create ./bar.

523

"""

524

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

525

526

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

527

import errno

528

from bzrlib.merge import merge

529

530

if to_location is None:

531

to_location = os.path.basename(from_location)

532

# FIXME: If there's a trailing slash, keep removing them

533

# until we find the right bit

534

535

try:

536

os.mkdir(to_location)

537

except OSError, e:

538

if e.errno == errno.EEXIST:

539

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

540

to_location)

541

if e.errno == errno.ENOENT:

542

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

543

to_location)

544

else:

545

raise

546

br_to = Branch(to_location, init=True)

547

from branch import find_branch, DivergedBranches

548

try:

549

br_from = find_branch(from_location)

550

except OSError, e:

551

if e.errno == errno.ENOENT:

552

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

553

to_location)

554

else:

555

raise

556

557

from_location = pull_loc(br_from)

558

br_to.update_revisions(br_from)

559

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

560

check_clean=False)

561

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

562

563

564

def pull_loc(branch):

565

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

566

# RemoteBranch and Branch?

567

if hasattr(branch, "baseurl"):

568

return branch.baseurl

569

else:

570

return branch.base

571

572

573

574

238

class cmd_renames(Command):

575

239

"""Show list of renamed files.

576

240

592

256

593

257

594

258

class cmd_info(Command):

595

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

596

takes_args = ['branch?']

597

598

def run(self, branch=None):

259

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

260

def run(self):

599

261

import info

600

601

from branch import find_branch

602

b = find_branch(branch)

603

info.show_info(b)

262

info.show_info(Branch('.'))

604

263

605

264

606

265

class cmd_remove(Command):

654

313

655

314

class cmd_revision_history(Command):

656

315

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

657

hidden = True

658

316

def run(self):

659

317

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

660

318

print patchid

712

370

"""

713

371

714

372

takes_args = ['file*']

715

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

716

aliases = ['di', 'dif']

373

takes_options = ['revision']

374

aliases = ['di']

717

375

718

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

376

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

719

377

from bzrlib.diff import show_diff

720

from bzrlib import find_branch

721

722

if file_list:

723

b = find_branch(file_list[0])

724

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

725

if file_list == ['']:

726

# just pointing to top-of-tree

727

file_list = None

728

else:

729

b = Branch('.')

730

378

731

show_diff(b, revision, specific_files=file_list,

732

external_diff_options=diff_options)

733

734

735

379

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

736

380

737

381

738

382

class cmd_deleted(Command):

757

401

else:

758

402

print path

759

403

760

761

class cmd_modified(Command):

762

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

763

hidden = True

764

def run(self):

765

import statcache

766

b = Branch('.')

767

inv = b.read_working_inventory()

768

sc = statcache.update_cache(b, inv)

769

basis = b.basis_tree()

770

basis_inv = basis.inventory

771

772

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

773

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

774

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

775

# calculate paths as necessary.

776

777

for file_id in basis_inv:

778

cacheentry = sc.get(file_id)

779

if not cacheentry: # deleted

780

continue

781

ie = basis_inv[file_id]

782

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

783

path = inv.id2path(file_id)

784

print path

785

786

787

788

class cmd_added(Command):

789

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

790

hidden = True

791

def run(self):

792

b = Branch('.')

793

wt = b.working_tree()

794

basis_inv = b.basis_tree().inventory

795

inv = wt.inventory

796

for file_id in inv:

797

if file_id in basis_inv:

798

continue

799

path = inv.id2path(file_id)

800

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

801

continue

802

print path

803

804

805

806

404

class cmd_root(Command):

807

405

"""Show the tree root directory.

808

406

811

409

takes_args = ['filename?']

812

410

def run(self, filename=None):

813

411

"""Print the branch root."""

814

from branch import find_branch

815

b = find_branch(filename)

816

print getattr(b, 'base', None) or getattr(b, 'baseurl')

412

print bzrlib.branch.find_branch_root(filename)

413

817

414

818

415

819

416

class cmd_log(Command):

820

417

"""Show log of this branch.

821

418

822

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

823

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

824

also valid.

825

826

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

827

419

TODO: Options to show ids; to limit range; etc.

828

420

"""

829

830

takes_args = ['filename?']

831

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

832

833

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

834

verbose=False,

835

show_ids=False,

836

forward=False,

837

revision=None):

838

from bzrlib import show_log, find_branch

839

import codecs

840

841

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

842

843

if filename:

844

b = find_branch(filename)

845

fp = b.relpath(filename)

846

if fp:

847

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

848

else:

849

file_id = None # points to branch root

850

else:

851

b = find_branch('.')

852

file_id = None

853

854

if revision == None:

855

revision = [None, None]

856

elif isinstance(revision, int):

857

revision = [revision, revision]

858

else:

859

# pair of revisions?

860

pass

861

862

assert len(revision) == 2

863

864

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

865

866

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

867

# in e.g. the default C locale.

868

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

869

870

show_log(b, file_id,

871

show_timezone=timezone,

872

verbose=verbose,

873

show_ids=show_ids,

874

to_file=outf,

875

direction=direction,

876

start_revision=revision[0],

877

end_revision=revision[1])

878

879

880

881

class cmd_touching_revisions(Command):

882

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

883

884

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

885

hidden = True

886

takes_args = ["filename"]

887

def run(self, filename):

888

b = Branch(filename)

889

inv = b.read_working_inventory()

890

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

891

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

892

print "%6d %s" % (revno, what)

421

takes_options = ['timezone', 'verbose']

422

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

423

Branch('.', lock_mode='r').write_log(show_timezone=timezone, verbose=verbose)

893

424

894

425

895

426

class cmd_ls(Command):

921

452

922

453

923

454

class cmd_unknowns(Command):

924

"""List unknown files."""

455

"""List unknown files"""

925

456

def run(self):

926

457

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

927

458

print quotefn(f)

929

460

930

461

931

462

class cmd_ignore(Command):

932

"""Ignore a command or pattern.

933

934

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

935

936

If the pattern contains a slash, it is compared to the whole path

937

from the branch root. Otherwise, it is comapred to only the last

938

component of the path.

939

940

Ignore patterns are case-insensitive on case-insensitive systems.

941

942

Note: wildcards must be quoted from the shell on Unix.

943

944

examples:

945

bzr ignore ./Makefile

946

bzr ignore '*.class'

947

"""

463

"""Ignore a command or pattern"""

948

464

takes_args = ['name_pattern']

949

465

950

466

def run(self, name_pattern):

951

from bzrlib.atomicfile import AtomicFile

952

import os.path

953

954

467

b = Branch('.')

955

ifn = b.abspath('.bzrignore')

956

957

if os.path.exists(ifn):

958

f = open(ifn, 'rt')

959

try:

960

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

961

finally:

962

f.close()

963

else:

964

igns = ''

965

966

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

967

# we should use that for the newly added lines?

968

969

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

970

igns += '\n'

971

igns += name_pattern + '\n'

972

973

try:

974

f = AtomicFile(ifn, 'wt')

975

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

976

f.commit()

977

finally:

978

f.close()

468

469

# XXX: This will fail if it's a hardlink; should use an AtomicFile class.

470

f = open(b.abspath('.bzrignore'), 'at')

471

f.write(name_pattern + '\n')

472

f.close()

979

473

980

474

inv = b.working_tree().inventory

981

475

if inv.path2id('.bzrignore'):

987

481

988

482

989

483

class cmd_ignored(Command):

990

"""List ignored files and the patterns that matched them.

991

992