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

1

2

3

# This program is free software; you can redistribute it and/or modify

4

# it under the terms of the GNU General Public License as published by

5

# the Free Software Foundation; either version 2 of the License, or

6

# (at your option) any later version.

7

8

# This program is distributed in the hope that it will be useful,

9

# but WITHOUT ANY WARRANTY; without even the implied warranty of

10

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11

# GNU General Public License for more details.

12

13

# You should have received a copy of the GNU General Public License

14

# along with this program; if not, write to the Free Software

15

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

16

17

18

import sys

19

import os

20

21

import bzrlib

22

import bzrlib.trace

23

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

24

from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError

25

from bzrlib.branch import find_branch

26

from bzrlib import BZRDIR

27

from bzrlib.commands import Command

28

29

30

class cmd_status(Command):

31

"""Display status summary.

32

33

This reports on versioned and unknown files, reporting them

34

grouped by state. Possible states are:

35

36

added

37

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

38

39

removed

40

Versioned in the previous revision but removed or deleted

41

in the working copy.

42

43

renamed

44

Path of this file changed from the previous revision;

45

the text may also have changed. This includes files whose

46

parent directory was renamed.

47

48

modified

49

Text has changed since the previous revision.

50

51

unchanged

52

Nothing about this file has changed since the previous revision.

53

Only shown with --all.

54

55

unknown

56

Not versioned and not matching an ignore pattern.

57

58

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

59

changes to file texts, use 'bzr diff'.

60

61

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

62

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

63

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

64

is reported for everything inside that directory.

65

"""

66

67

takes_args = ['file*']

68

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

69

aliases = ['st', 'stat']

70

71

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

72

if file_list:

73

b = find_branch(file_list[0])

74

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

75

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

76

# of the branch

77

if file_list == ['']:

78

file_list = None

79

else:

80

b = find_branch('.')

81

82

from bzrlib.status import show_status

83

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

84

specific_files=file_list)

85

86

87

class cmd_cat_revision(Command):

88

"""Write out metadata for a revision."""

89

90

hidden = True

91

takes_args = ['revision_id']

92

93

def run(self, revision_id):

94

b = find_branch('.')

95

sys.stdout.write(b.get_revision_xml_file(revision_id).read())

96

97

98

class cmd_revno(Command):

99

"""Show current revision number.

100

101

This is equal to the number of revisions on this branch."""

102

def run(self):

103

print find_branch('.').revno()

104

105

106

class cmd_revision_info(Command):

107

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

108

"""

109

hidden = True

110

takes_args = ['revision_info*']

111

takes_options = ['revision']

112

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

113

from bzrlib.branch import find_branch

114

115

revs = []

116

if revision is not None:

117

revs.extend(revision)

118

if revision_info_list is not None:

119

revs.extend(revision_info_list)

120

if len(revs) == 0:

121

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

122

123

b = find_branch('.')

124

125

for rev in revs:

126

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

127

128

129

class cmd_add(Command):

130

"""Add specified files or directories.

131

132

In non-recursive mode, all the named items are added, regardless

133

of whether they were previously ignored. A warning is given if

134

any of the named files are already versioned.

135

136

In recursive mode (the default), files are treated the same way

137

but the behaviour for directories is different. Directories that

138

are already versioned do not give a warning. All directories,

139

whether already versioned or not, are searched for files or

140

subdirectories that are neither versioned or ignored, and these

141

are added. This search proceeds recursively into versioned

142

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

143

144

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

145

are currently unknown.

146

147

Adding a file whose parent directory is not versioned will

148

implicitly add the parent, and so on up to the root. This means

149

you should never need to explictly add a directory, they'll just

150

get added when you add a file in the directory.

151

"""

152

takes_args = ['file*']

153

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

154

155

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

156

# verbose currently has no effect

157

from bzrlib.add import smart_add, add_reporter_print

158

smart_add(file_list, not no_recurse, add_reporter_print)

159

160

161

162

class cmd_mkdir(Command):

163

"""Create a new versioned directory.

164

165

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

166

"""

167

takes_args = ['dir+']

168

169

def run(self, dir_list):

170

b = None

171

172

for d in dir_list:

173

os.mkdir(d)

174

if not b:

175

b = find_branch(d)

176

b.add([d])

177

print 'added', d

178

179

180

class cmd_relpath(Command):

181

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

182

takes_args = ['filename']

183

hidden = True

184

185

def run(self, filename):

186

print find_branch(filename).relpath(filename)

187

188

189

190

class cmd_inventory(Command):

191

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

192

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

193

194

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

195

b = find_branch('.')

196

if revision == None:

197

inv = b.read_working_inventory()

198

else:

199

if len(revision) > 1:

200

raise BzrCommandError('bzr inventory --revision takes'

201

' exactly one revision identifier')

202

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

203

204

for path, entry in inv.entries():

205

if show_ids:

206

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

207

else:

208

print path

209

210

211

class cmd_move(Command):

212

"""Move files to a different directory.

213

214

examples:

215

bzr move *.txt doc

216

217

The destination must be a versioned directory in the same branch.

218

"""

219

takes_args = ['source$', 'dest']

220

def run(self, source_list, dest):

221

b = find_branch('.')

222

223

# TODO: glob expansion on windows?

224

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

225

226

227

class cmd_rename(Command):

228

"""Change the name of an entry.

229

230

examples:

231

bzr rename frob.c frobber.c

232

bzr rename src/frob.c lib/frob.c

233

234

It is an error if the destination name exists.

235

236

See also the 'move' command, which moves files into a different

237

directory without changing their name.

238

239

TODO: Some way to rename multiple files without invoking bzr for each

240

one?"""

241

takes_args = ['from_name', 'to_name']

242

243

def run(self, from_name, to_name):

244

b = find_branch('.')

245

b.rename_one(b.relpath(from_name), b.relpath(to_name))

246

247

248

249

class cmd_mv(Command):

250

"""Move or rename a file.

251

252

usage:

253

bzr mv OLDNAME NEWNAME

254

bzr mv SOURCE... DESTINATION

255

256

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

257

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

258

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

259

260

Files cannot be moved between branches.

261

"""

262

takes_args = ['names*']

263

def run(self, names_list):

264

if len(names_list) < 2:

265

raise BzrCommandError("missing file argument")

266

b = find_branch(names_list[0])

267

268

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

269

270

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

271

# move into existing directory

272

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

273

print "%s => %s" % pair

274

else:

275

if len(names_list) != 2:

276

raise BzrCommandError('to mv multiple files the destination '

277

'must be a versioned directory')

278

for pair in b.move(rel_names[0], rel_names[1]):

279

print "%s => %s" % pair

280

281

282

283

284

class cmd_pull(Command):

285

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

286

287

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

288

Both the revision history and the working directory will be

289

updated.

290

291

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

292

considered diverged if both branches have had commits without first

293

pulling from the other.

294

295

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

296

from one into the other.

297

"""

298

takes_args = ['location?']

299

300

def run(self, location=None):

301

from bzrlib.merge import merge

302

import tempfile

303

from shutil import rmtree

304

import errno

305

from bzrlib.branch import pull_loc

306

307

br_to = find_branch('.')

308

stored_loc = None

309

try:

310

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

311

except IOError, e:

312

if e.errno != errno.ENOENT:

313

raise

314

if location is None:

315

if stored_loc is None:

316

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

317

else:

318

print "Using last location: %s" % stored_loc

319

location = stored_loc

320

cache_root = tempfile.mkdtemp()

321

from bzrlib.branch import DivergedBranches

322

br_from = find_branch(location)

323

location = pull_loc(br_from)

324

old_revno = br_to.revno()

325

try:

326

from branch import find_cached_branch, DivergedBranches

327

br_from = find_cached_branch(location, cache_root)

328

location = pull_loc(br_from)

329

old_revno = br_to.revno()

330

try:

331

br_to.update_revisions(br_from)

332

except DivergedBranches:

333

raise BzrCommandError("These branches have diverged."

334

" Try merge.")

335

336

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

337

if location != stored_loc:

338

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

339

finally:

340

rmtree(cache_root)

341

342

343

344

class cmd_branch(Command):

345

"""Create a new copy of a branch.

346

347

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

348

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

349

350

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

351

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

352

"""

353

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

354

takes_options = ['revision']

355

aliases = ['get', 'clone']

356

357

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

358

from bzrlib.branch import copy_branch, find_cached_branch

359

import tempfile

360

import errno

361

from shutil import rmtree

362

cache_root = tempfile.mkdtemp()

363

try:

364

if revision is None:

365

revision = [None]

366

elif len(revision) > 1:

367

raise BzrCommandError(

368

'bzr branch --revision takes exactly 1 revision value')

369

try:

370

br_from = find_cached_branch(from_location, cache_root)

371

except OSError, e:

372

if e.errno == errno.ENOENT:

373

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

374

' exist.' % to_location)

375

else:

376

raise

377

if to_location is None:

378

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

379

try:

380

os.mkdir(to_location)

381

except OSError, e:

382

if e.errno == errno.EEXIST:

383

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

384

' exists.' % to_location)

385

if e.errno == errno.ENOENT:

386

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

387

to_location)

388

else:

389

raise

390

try:

391

copy_branch(br_from, to_location, revision[0])

392

except bzrlib.errors.NoSuchRevision:

393

rmtree(to_location)

394

msg = "The branch %s has no revision %d." % (from_location, revision[0])

395

raise BzrCommandError(msg)

396

finally:

397

rmtree(cache_root)

398

399

400

class cmd_renames(Command):

401

"""Show list of renamed files.

402

403

TODO: Option to show renames between two historical versions.

404

405

TODO: Only show renames under dir, rather than in the whole branch.

406

"""

407

takes_args = ['dir?']

408

409

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

410

b = find_branch(dir)

411

old_inv = b.basis_tree().inventory

412

new_inv = b.read_working_inventory()

413

414

renames = list(bzrlib.tree.find_renames(old_inv, new_inv))

415

renames.sort()

416

for old_name, new_name in renames:

417

print "%s => %s" % (old_name, new_name)

418

419

420

class cmd_info(Command):

421

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

422

takes_args = ['branch?']

423

424

def run(self, branch=None):

425

import info

426

427

b = find_branch(branch)

428

info.show_info(b)

429

430

431

class cmd_remove(Command):

432

"""Make a file unversioned.

433

434

This makes bzr stop tracking changes to a versioned file. It does

435

not delete the working copy.

436

"""

437

takes_args = ['file+']

438

takes_options = ['verbose']

439

440

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

441

b = find_branch(file_list[0])

442

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

443

444

445

class cmd_file_id(Command):

446

"""Print file_id of a particular file or directory.

447

448

The file_id is assigned when the file is first added and remains the

449

same through all revisions where the file exists, even when it is

450

moved or renamed.

451

"""

452

hidden = True

453

takes_args = ['filename']

454

def run(self, filename):

455

b = find_branch(filename)

456

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

457

if i == None:

458

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

459

else:

460

print i

461

462

463

class cmd_file_path(Command):

464

"""Print path of file_ids to a file or directory.

465

466

This prints one line for each directory down to the target,

467

starting at the branch root."""

468

hidden = True

469

takes_args = ['filename']

470

def run(self, filename):

471

b = find_branch(filename)

472

inv = b.inventory

473

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

474

if fid == None:

475

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

476

for fip in inv.get_idpath(fid):

477

print fip

478

479

480

class cmd_revision_history(Command):

481

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

482

hidden = True

483

def run(self):

484

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

485

print patchid

486

487

488

class cmd_directories(Command):

489

"""Display list of versioned directories in this branch."""

490

def run(self):

491

for name, ie in find_branch('.').read_working_inventory().directories():

492

if name == '':

493

print '.'

494

else:

495

print name

496

497

498

class cmd_init(Command):

499

"""Make a directory into a versioned branch.

500

501

Use this to create an empty branch, or before importing an

502

existing project.

503

504

Recipe for importing a tree of files:

505

cd ~/project

506

bzr init

507

bzr add -v .

508

bzr status

509

bzr commit -m 'imported project'

510

"""

511

def run(self):

512

from bzrlib.branch import Branch

513

Branch('.', init=True)

514

515

516

class cmd_diff(Command):

517

"""Show differences in working tree.

518

519

If files are listed, only the changes in those files are listed.

520

Otherwise, all changes for the tree are listed.

521

522

TODO: Allow diff across branches.

523

524

TODO: Option to use external diff command; could be GNU diff, wdiff,

525

or a graphical diff.

526

527

TODO: Python difflib is not exactly the same as unidiff; should

528

either fix it up or prefer to use an external diff.

529

530

TODO: If a directory is given, diff everything under that.

531

532

TODO: Selected-file diff is inefficient and doesn't show you

533

deleted files.

534

535

TODO: This probably handles non-Unix newlines poorly.

536

537

examples:

538

bzr diff

539

bzr diff -r1

540

bzr diff -r1..2

541

"""

542

543

takes_args = ['file*']

544

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

545

aliases = ['di', 'dif']

546

547

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

548

from bzrlib.diff import show_diff

549

550

if file_list:

551

b = find_branch(file_list[0])

552

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

553

if file_list == ['']:

554

# just pointing to top-of-tree

555

file_list = None

556

else:

557

b = find_branch('.')

558

559

if revision is not None:

560

if len(revision) == 1:

561

show_diff(b, revision[0], specific_files=file_list,

562

external_diff_options=diff_options)

563

elif len(revision) == 2:

564

show_diff(b, revision[0], specific_files=file_list,

565

external_diff_options=diff_options,

566

revision2=revision[1])

567

else:

568

raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')

569

else:

570

show_diff(b, None, specific_files=file_list,

571

external_diff_options=diff_options)

572

573

574

575

576

class cmd_deleted(Command):

577

"""List files deleted in the working tree.

578

579

TODO: Show files deleted since a previous revision, or between two revisions.

580

"""

581

def run(self, show_ids=False):

582

b = find_branch('.')

583

old = b.basis_tree()

584

new = b.working_tree()

585

586

## TODO: Much more efficient way to do this: read in new

587

## directories with readdir, rather than stating each one. Same

588

## level of effort but possibly much less IO. (Or possibly not,

589

## if the directories are very large...)

590

591

for path, ie in old.inventory.iter_entries():

592

if not new.has_id(ie.file_id):

593

if show_ids:

594

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

595

else:

596

print path

597

598

599

class cmd_modified(Command):

600

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

601

hidden = True

602

def run(self):

603

from bzrlib.delta import compare_trees

604

605

b = find_branch('.')

606

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

607

608

for path, id, kind in td.modified:

609

print path

610

611

612

613

class cmd_added(Command):

614

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

615

hidden = True

616

def run(self):

617

b = find_branch('.')

618

wt = b.working_tree()

619

basis_inv = b.basis_tree().inventory

620

inv = wt.inventory

621

for file_id in inv:

622

if file_id in basis_inv:

623

continue

624

path = inv.id2path(file_id)

625

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

626

continue

627

print path

628

629

630

631

class cmd_root(Command):

632

"""Show the tree root directory.

633

634

The root is the nearest enclosing directory with a .bzr control

635

directory."""

636

takes_args = ['filename?']

637

def run(self, filename=None):

638

"""Print the branch root."""

639

b = find_branch(filename)

640

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

641

642

643

class cmd_log(Command):

644

"""Show log of this branch.

645

646

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

647

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

648

also valid.

649

650

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

651

so that only matching entries will be displayed.

652

653

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

654

655

"""

656

657

takes_args = ['filename?']

658

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

659

'long', 'message', 'short',]

660

661

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

662

verbose=False,

663

show_ids=False,

664

forward=False,

665

revision=None,

666

message=None,

667

long=False,

668

short=False):

669

from bzrlib.log import log_formatter, show_log

670

import codecs

671

672

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

673

674

if filename:

675

b = find_branch(filename)

676

fp = b.relpath(filename)

677

if fp:

678

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

679

else:

680

file_id = None # points to branch root

681

else:

682

b = find_branch('.')

683

file_id = None

684

685

if revision is None:

686

rev1 = None

687

rev2 = None

688

elif len(revision) == 1:

689

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

690

elif len(revision) == 2:

691

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

692

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

693

else:

694

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

695

696

if rev1 == 0:

697

rev1 = None

698

if rev2 == 0:

699

rev2 = None

700

701

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

702

703

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

704

# in e.g. the default C locale.

705

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

706

707

if not short:

708

log_format = 'long'

709

else:

710

log_format = 'short'

711

lf = log_formatter(log_format,

712

show_ids=show_ids,

713

to_file=outf,

714

show_timezone=timezone)

715

716

show_log(b,

717

lf,

718

file_id,

719

verbose=verbose,

720

direction=direction,

721

start_revision=rev1,

722

end_revision=rev2,

723

search=message)

724

725

726

727

class cmd_touching_revisions(Command):

728

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

729

730

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

731

hidden = True

732

takes_args = ["filename"]

733

def run(self, filename):

734

b = find_branch(filename)

735

inv = b.read_working_inventory()

736

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

737

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

738

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

739

740

741

class cmd_ls(Command):

742

"""List files in a tree.

743

744

TODO: Take a revision or remote path and list that tree instead.

745

"""

746

hidden = True

747

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

748

b = find_branch('.')

749

if revision == None:

750

tree = b.working_tree()

751

else:

752

tree = b.revision_tree(b.lookup_revision(revision))

753

754

for fp, fc, kind, fid in tree.list_files():

755

if verbose:

756

if kind == 'directory':

757

kindch = '/'

758

elif kind == 'file':

759

kindch = ''

760

else:

761

kindch = '???'

762

763

print '%-8s %s%s' % (fc, fp, kindch)

764

else:

765

print fp

766

767

768

769

class cmd_unknowns(Command):

770

"""List unknown files."""

771

def run(self):

772

from bzrlib.osutils import quotefn

773

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

774

print quotefn(f)

775

776

777

778

class cmd_ignore(Command):

779

"""Ignore a command or pattern.

780

781

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

782

783

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

784

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

785

component of the path.

786

787

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

788

789

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

790

791

examples:

792

bzr ignore ./Makefile

793

bzr ignore '*.class'

794

"""

795

takes_args = ['name_pattern']

796

797

def run(self, name_pattern):

798

from bzrlib.atomicfile import AtomicFile

799

import os.path

800

801

b = find_branch('.')

802

ifn = b.abspath('.bzrignore')

803

804

if os.path.exists(ifn):

805

f = open(ifn, 'rt')

806

try:

807

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

808

finally:

809

f.close()

810

else:

811

igns = ''

812

813

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

814

# we should use that for the newly added lines?

815

816

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

817

igns += '\n'

818

igns += name_pattern + '\n'

819

820

try:

821

f = AtomicFile(ifn, 'wt')

822

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

823

f.commit()

824

finally:

825

f.close()

826

827

inv = b.working_tree().inventory

828

if inv.path2id('.bzrignore'):

829

mutter('.bzrignore is already versioned')

830

else:

831

mutter('need to make new .bzrignore file versioned')

832

b.add(['.bzrignore'])

833

834

835

836

class cmd_ignored(Command):

837

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

838

839