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

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

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

67

"""

68

takes_args = ['file*']

69

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

70

aliases = ['st', 'stat']

71

72

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

73

if file_list:

74

b = find_branch(file_list[0])

75

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

76

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

77

# of the branch

78

if file_list == ['']:

79

file_list = None

80

else:

81

b = find_branch('.')

82

83

from bzrlib.status import show_status

84

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

85

specific_files=file_list)

86

87

88

class cmd_cat_revision(Command):

89

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

90

91

hidden = True

92

takes_args = ['revision_id']

93

94

def run(self, revision_id):

95

from bzrlib.xml import pack_xml

96

pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)

97

98

99

class cmd_revno(Command):

100

"""Show current revision number.

101

102

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

103

def run(self):

104

print find_branch('.').revno()

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

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

148

recursively add that parent, rather than giving an error?

149

"""

150

takes_args = ['file*']

151

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

152

153

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

154

# verbose currently has no effect

155

from bzrlib.add import smart_add, add_reporter_print

156

smart_add(file_list, not no_recurse, add_reporter_print)

157

158

159

160

class cmd_mkdir(Command):

161

"""Create a new versioned directory.

162

163

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

164

"""

165

takes_args = ['dir+']

166

167

def run(self, dir_list):

168

b = None

169

170

for d in dir_list:

171

os.mkdir(d)

172

if not b:

173

b = find_branch(d)

174

b.add([d])

175

print 'added', d

176

177

178

class cmd_relpath(Command):

179

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

180

takes_args = ['filename']

181

hidden = True

182

183

def run(self, filename):

184

print find_branch(filename).relpath(filename)

185

186

187

188

class cmd_inventory(Command):

189

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

190

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

191

192

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

193

b = find_branch('.')

194

if revision == None:

195

inv = b.read_working_inventory()

196

else:

197

if len(revision) > 1:

198

raise BzrCommandError('bzr inventory --revision takes'

199

' exactly one revision identifier')

200

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

201

202

for path, entry in inv.entries():

203

if show_ids:

204

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

205

else:

206

print path

207

208

209

class cmd_move(Command):

210

"""Move files to a different directory.

211

212

examples:

213

bzr move *.txt doc

214

215

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

216

"""

217

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

218

def run(self, source_list, dest):

219

b = find_branch('.')

220

221

# TODO: glob expansion on windows?

222

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

223

224

225

class cmd_rename(Command):

226

"""Change the name of an entry.

227

228

examples:

229

bzr rename frob.c frobber.c

230

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

231

232

It is an error if the destination name exists.

233

234

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

235

directory without changing their name.

236

237

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

238

one?"""

239

takes_args = ['from_name', 'to_name']

240

241

def run(self, from_name, to_name):

242

b = find_branch('.')

243

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

244

245

246

247

class cmd_mv(Command):

248

"""Move or rename a file.

249

250

usage:

251

bzr mv OLDNAME NEWNAME

252

bzr mv SOURCE... DESTINATION

253

254

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

255

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

256

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

257

258

Files cannot be moved between branches.

259

"""

260

takes_args = ['names*']

261

def run(self, names_list):

262

if len(names_list) < 2:

263

raise BzrCommandError("missing file argument")

264

b = find_branch(names_list[0])

265

266

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

267

268

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

269

# move into existing directory

270

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

271

print "%s => %s" % pair

272

else:

273

if len(names_list) != 2:

274

raise BzrCommandError('to mv multiple files the destination '

275

'must be a versioned directory')

276

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

277

print "%s => %s" % pair

278

279

280

281

282

class cmd_pull(Command):

283

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

284

285

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

286

Both the revision history and the working directory will be

287

updated.

288

289

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

290

considered diverged if both branches have had commits without first

291

pulling from the other.

292

293

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

294

from one into the other.

295

"""

296

takes_args = ['location?']

297

298

def run(self, location=None):

299

from bzrlib.merge import merge

300

import tempfile

301

from shutil import rmtree

302

import errno

303

from bzrlib.branch import pull_loc

304

305

br_to = find_branch('.')

306

stored_loc = None

307

try:

308

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

309

except IOError, e:

310

if e.errno != errno.ENOENT:

311

raise

312

if location is None:

313

if stored_loc is None:

314

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

315

else:

316

print "Using last location: %s" % stored_loc

317

location = stored_loc

318

cache_root = tempfile.mkdtemp()

319

from bzrlib.branch import DivergedBranches

320

br_from = find_branch(location)

321

location = pull_loc(br_from)

322

old_revno = br_to.revno()

323

try:

324

from branch import find_cached_branch, DivergedBranches

325

br_from = find_cached_branch(location, cache_root)

326

location = pull_loc(br_from)

327

old_revno = br_to.revno()

328

try:

329

br_to.update_revisions(br_from)

330

except DivergedBranches:

331

raise BzrCommandError("These branches have diverged."

332

" Try merge.")

333

334

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

335

if location != stored_loc:

336

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

337

finally:

338

rmtree(cache_root)

339

340

341

342

class cmd_branch(Command):

343

"""Create a new copy of a branch.

344

345

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

346

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

347

348

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

349

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

350

"""

351

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

352

takes_options = ['revision']

353

aliases = ['get', 'clone']

354

355

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

356

from bzrlib.branch import copy_branch, find_cached_branch

357

import tempfile

358

import errno

359

from shutil import rmtree

360

cache_root = tempfile.mkdtemp()

361

try:

362

if revision is None:

363

revision = [None]

364

elif len(revision) > 1:

365

raise BzrCommandError(

366

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

367

try:

368

br_from = find_cached_branch(from_location, cache_root)

369

except OSError, e:

370

if e.errno == errno.ENOENT:

371

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

372

' exist.' % to_location)

373

else:

374

raise

375

if to_location is None:

376

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

377

try:

378

os.mkdir(to_location)

379

except OSError, e:

380

if e.errno == errno.EEXIST:

381

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

382

' exists.' % to_location)

383

if e.errno == errno.ENOENT:

384

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

385

to_location)

386

else:

387

raise

388

try:

389

copy_branch(br_from, to_location, revision[0])

390

except bzrlib.errors.NoSuchRevision:

391

rmtree(to_location)

392

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

393

raise BzrCommandError(msg)

394

finally:

395

rmtree(cache_root)

396

397

398

class cmd_renames(Command):

399

"""Show list of renamed files.

400

401

TODO: Option to show renames between two historical versions.

402

403

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

404

"""

405

takes_args = ['dir?']

406

407

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

408

b = find_branch(dir)

409

old_inv = b.basis_tree().inventory

410

new_inv = b.read_working_inventory()

411

412

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

413

renames.sort()

414

for old_name, new_name in renames:

415

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

416

417

418

class cmd_info(Command):

419

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

420

takes_args = ['branch?']

421

422

def run(self, branch=None):

423

import info

424

425

b = find_branch(branch)

426

info.show_info(b)

427

428

429

class cmd_remove(Command):

430

"""Make a file unversioned.

431

432

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

433

not delete the working copy.

434

"""

435

takes_args = ['file+']

436

takes_options = ['verbose']

437

438

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

439

b = find_branch(file_list[0])

440

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

441

442

443

class cmd_file_id(Command):

444

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

445

446

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

447

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

448

moved or renamed.

449

"""

450

hidden = True

451

takes_args = ['filename']

452

def run(self, filename):

453

b = find_branch(filename)

454

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

455

if i == None:

456

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

457

else:

458

print i

459

460

461

class cmd_file_path(Command):

462

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

463

464

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

465

starting at the branch root."""

466

hidden = True

467

takes_args = ['filename']

468

def run(self, filename):

469

b = find_branch(filename)

470

inv = b.inventory

471

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

472

if fid == None:

473

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

474

for fip in inv.get_idpath(fid):

475

print fip

476

477

478

class cmd_revision_history(Command):

479

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

480

hidden = True

481

def run(self):

482

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

483

print patchid

484

485

486

class cmd_directories(Command):

487

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

488

def run(self):

489

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

490

if name == '':

491

print '.'

492

else:

493

print name

494

495

496

class cmd_init(Command):

497

"""Make a directory into a versioned branch.

498

499

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

500

existing project.

501

502

Recipe for importing a tree of files:

503

cd ~/project

504

bzr init

505

bzr add -v .

506

bzr status

507

bzr commit -m 'imported project'

508

"""

509

def run(self):

510

from bzrlib.branch import Branch

511

Branch('.', init=True)

512

513

514

class cmd_diff(Command):

515

"""Show differences in working tree.

516

517

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

518

Otherwise, all changes for the tree are listed.

519

520

TODO: Allow diff across branches.

521

522

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

523

or a graphical diff.

524

525

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

526

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

527

528

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

529

530

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

531

deleted files.

532

533

TODO: This probably handles non-Unix newlines poorly.

534

535

examples:

536

bzr diff

537

bzr diff -r1

538

bzr diff -r1:2

539

"""

540

541

takes_args = ['file*']

542

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

543

aliases = ['di', 'dif']

544

545

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

546

from bzrlib.diff import show_diff

547

548

if file_list:

549

b = find_branch(file_list[0])

550

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

551

if file_list == ['']:

552

# just pointing to top-of-tree

553

file_list = None

554

else:

555

b = find_branch('.')

556

557

if revision is not None:

558

if len(revision) == 1:

559

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

560

external_diff_options=diff_options)

561

elif len(revision) == 2:

562

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

563

external_diff_options=diff_options,

564

revision2=revision[1])

565

else:

566

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

567

else:

568

show_diff(b, None, specific_files=file_list,

569

external_diff_options=diff_options)

570

571

572

573

574

class cmd_deleted(Command):

575

"""List files deleted in the working tree.

576

577

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

578

"""

579

def run(self, show_ids=False):

580

b = find_branch('.')

581

old = b.basis_tree()

582

new = b.working_tree()

583

584

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

585

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

586

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

587

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

588

589

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

590

if not new.has_id(ie.file_id):

591

if show_ids:

592

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

593

else:

594

print path

595

596

597

class cmd_modified(Command):

598

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

599

hidden = True

600

def run(self):

601

from bzrlib.delta import compare_trees

602

603

b = find_branch('.')

604

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

605

606

for path, id, kind in td.modified:

607

print path

608

609

610

611

class cmd_added(Command):

612

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

613

hidden = True

614

def run(self):

615

b = find_branch('.')

616

wt = b.working_tree()

617

basis_inv = b.basis_tree().inventory

618

inv = wt.inventory

619

for file_id in inv:

620

if file_id in basis_inv:

621

continue

622

path = inv.id2path(file_id)

623

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

624

continue

625

print path

626

627

628

629

class cmd_root(Command):

630

"""Show the tree root directory.

631

632

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

633

directory."""

634

takes_args = ['filename?']

635

def run(self, filename=None):

636

"""Print the branch root."""

637

b = find_branch(filename)

638

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

639

640

641

class cmd_log(Command):

642

"""Show log of this branch.

643

644

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

645

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

646

also valid.

647

648

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

649

so that only matching entries will be displayed.

650

651

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

652

653

"""

654

655

takes_args = ['filename?']

656

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

657

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

658

659

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

660

verbose=False,

661

show_ids=False,

662

forward=False,

663

revision=None,

664

message=None,

665

long=False,

666

short=False):

667

from bzrlib.log import log_formatter, show_log

668

import codecs

669

670

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

671

672

if filename:

673

b = find_branch(filename)

674

fp = b.relpath(filename)

675

if fp:

676

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

677

else:

678

file_id = None # points to branch root

679

else:

680

b = find_branch('.')

681

file_id = None

682

683

if revision is None:

684

rev1 = None

685

rev2 = None

686

elif len(revision) == 1:

687

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

688

elif len(revision) == 2:

689

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

690

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

691

else:

692

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

693

694

if rev1 == 0:

695

rev1 = None

696

if rev2 == 0:

697

rev2 = None

698

699

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

700

701

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

702

# in e.g. the default C locale.

703

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

704

705

if not short:

706

log_format = 'long'

707

else:

708

log_format = 'short'

709

lf = log_formatter(log_format,

710

show_ids=show_ids,

711

to_file=outf,

712

show_timezone=timezone)

713

714

show_log(b,

715

lf,

716

file_id,

717

verbose=verbose,

718

direction=direction,

719

start_revision=rev1,

720

end_revision=rev2,

721

search=message)

722

723

724

725

class cmd_touching_revisions(Command):

726

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

727

728

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

729

hidden = True

730

takes_args = ["filename"]

731

def run(self, filename):

732

b = find_branch(filename)

733

inv = b.read_working_inventory()

734

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

735

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

736

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

737

738

739

class cmd_ls(Command):

740

"""List files in a tree.

741

742

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

743

"""

744

hidden = True

745

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

746

b = find_branch('.')

747

if revision == None:

748

tree = b.working_tree()

749

else:

750

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

751

752

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

753

if verbose:

754

if kind == 'directory':

755

kindch = '/'

756

elif kind == 'file':

757

kindch = ''

758

else:

759

kindch = '???'

760

761

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

762

else:

763

print fp

764

765

766

767

class cmd_unknowns(Command):

768

"""List unknown files."""

769

def run(self):

770

from bzrlib.osutils import quotefn

771

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

772

print quotefn(f)

773

774

775

776

class cmd_ignore(Command):

777

"""Ignore a command or pattern.

778

779

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

780

781

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

782

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

783

component of the path.

784

785

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

786

787

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

788

789

examples:

790

bzr ignore ./Makefile

791

bzr ignore '*.class'

792

"""

793

takes_args = ['name_pattern']

794

795

def run(self, name_pattern):

796

from bzrlib.atomicfile import AtomicFile

797

import os.path

798

799

b = find_branch('.')

800

ifn = b.abspath('.bzrignore')

801

802

if os.path.exists(ifn):

803

f = open(ifn, 'rt')

804

try:

805

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

806

finally:

807

f.close()

808

else:

809

igns = ''

810

811

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

812

# we should use that for the newly added lines?

813

814

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

815

igns += '\n'

816

igns += name_pattern + '\n'

817

818

try:

819

f = AtomicFile(ifn, 'wt')

820

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

821

f.commit()

822

finally:

823

f.close()

824

825

inv = b.working_tree().inventory

826

if inv.path2id('.bzrignore'):

827

mutter('.bzrignore is already versioned')

828

else:

829

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

830

b.add(['.bzrignore'])

831

832

833

834

class cmd_ignored(Command):

835

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

836

837