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

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

# XXX: FIXME: bzr status should accept a -r option to show changes

67

# relative to a revision, or between revisions

68

69

takes_args = ['file*']

70

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

71

aliases = ['st', 'stat']

72

73

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

74

if file_list:

75

b = Branch.open_containing(file_list[0])

76

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

77

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

78

# of the branch

79

if file_list == ['']:

80

file_list = None

81

else:

82

b = Branch.open_containing('.')

83

84

from bzrlib.status import show_status

85

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

86

specific_files=file_list)

87

88

89

class cmd_cat_revision(Command):

90

"""Write out metadata for a revision.

91

92

The revision to print can either be specified by a specific

93

revision identifier, or you can use --revision.

94

"""

95

96

hidden = True

97

takes_args = ['revision_id?']

98

takes_options = ['revision']

99

100

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

101

from bzrlib.revisionspec import RevisionSpec

102

103

if revision_id is not None and revision is not None:

104

raise BzrCommandError('You can only supply one of revision_id or --revision')

105

if revision_id is None and revision is None:

106

raise BzrCommandError('You must supply either --revision or a revision_id')

107

b = Branch.open_containing('.')

108

if revision_id is not None:

109

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

110

elif revision is not None:

111

for rev in revision:

112

if rev is None:

113

raise BzrCommandError('You cannot specify a NULL revision.')

114

revno, rev_id = rev.in_history(b)

115

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

116

117

118

class cmd_revno(Command):

119

"""Show current revision number.

120

121

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

122

def run(self):

123

print Branch.open_containing('.').revno()

124

125

126

class cmd_revision_info(Command):

127

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

128

"""

129

hidden = True

130

takes_args = ['revision_info*']

131

takes_options = ['revision']

132

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

133

from bzrlib.revisionspec import RevisionSpec

134

135

revs = []

136

if revision is not None:

137

revs.extend(revision)

138

if revision_info_list is not None:

139

for rev in revision_info_list:

140

revs.append(RevisionSpec(rev))

141

if len(revs) == 0:

142

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

143

144

b = Branch.open_containing('.')

145

146

for rev in revs:

147

revinfo = rev.in_history(b)

148

if revinfo.revno is None:

149

print ' %s' % revinfo.rev_id

150

else:

151

print '%4d %s' % (revinfo.revno, revinfo.rev_id)

152

153

154

class cmd_add(Command):

155

"""Add specified files or directories.

156

157

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

158

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

159

any of the named files are already versioned.

160

161

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

162

but the behaviour for directories is different. Directories that

163

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

164

whether already versioned or not, are searched for files or

165

subdirectories that are neither versioned or ignored, and these

166

are added. This search proceeds recursively into versioned

167

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

168

169

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

170

are currently unknown.

171

172

Adding a file whose parent directory is not versioned will

173

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

174

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

175

get added when you add a file in the directory.

176

"""

177

takes_args = ['file*']

178

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

179

180

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

181

# verbose currently has no effect

182

from bzrlib.add import smart_add, add_reporter_print

183

smart_add(file_list, not no_recurse, add_reporter_print)

184

185

186

187

class cmd_mkdir(Command):

188

"""Create a new versioned directory.

189

190

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

191

"""

192

takes_args = ['dir+']

193

194

def run(self, dir_list):

195

b = None

196

197

for d in dir_list:

198

os.mkdir(d)

199

if not b:

200

b = Branch.open_containing(d)

201

b.add([d])

202

print 'added', d

203

204

205

class cmd_relpath(Command):

206

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

207

takes_args = ['filename']

208

hidden = True

209

210

def run(self, filename):

211

print Branch.open_containing(filename).relpath(filename)

212

213

214

215

class cmd_inventory(Command):

216

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

217

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

218

219

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

220

b = Branch.open_containing('.')

221

if revision is None:

222

inv = b.read_working_inventory()

223

else:

224

if len(revision) > 1:

225

raise BzrCommandError('bzr inventory --revision takes'

226

' exactly one revision identifier')

227

inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)

228

229

for path, entry in inv.entries():

230

if show_ids:

231

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

232

else:

233

print path

234

235

236

class cmd_move(Command):

237

"""Move files to a different directory.

238

239

examples:

240

bzr move *.txt doc

241

242

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

243

"""

244

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

245

def run(self, source_list, dest):

246

b = Branch.open_containing('.')

247

248

# TODO: glob expansion on windows?

249

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

250

251

252

class cmd_rename(Command):

253

"""Change the name of an entry.

254

255

examples:

256

bzr rename frob.c frobber.c

257

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

258

259

It is an error if the destination name exists.

260

261

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

262

directory without changing their name.

263

264

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

265

one?"""

266

takes_args = ['from_name', 'to_name']

267

268

def run(self, from_name, to_name):

269

b = Branch.open_containing('.')

270

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

271

272

273

274

class cmd_mv(Command):

275

"""Move or rename a file.

276

277

usage:

278

bzr mv OLDNAME NEWNAME

279

bzr mv SOURCE... DESTINATION

280

281

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

282

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

283

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

284

285

Files cannot be moved between branches.

286

"""

287

takes_args = ['names*']

288

def run(self, names_list):

289

if len(names_list) < 2:

290

raise BzrCommandError("missing file argument")

291

b = Branch.open_containing(names_list[0])

292

293

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

294

295

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

296

# move into existing directory

297

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

298

print "%s => %s" % pair

299

else:

300

if len(names_list) != 2:

301

raise BzrCommandError('to mv multiple files the destination '

302

'must be a versioned directory')

303

b.rename_one(rel_names[0], rel_names[1])

304

print "%s => %s" % (rel_names[0], rel_names[1])

305

306

307

308

309

class cmd_pull(Command):

310

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

311

312

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

313

Both the revision history and the working directory will be

314

updated.

315

316

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

317

considered diverged if both branches have had commits without first

318

pulling from the other.

319

320

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

321

from one into the other.

322

"""

323

takes_args = ['location?']

324

325

def run(self, location=None):

326

from bzrlib.merge import merge

327

import tempfile

328

from shutil import rmtree

329

import errno

330

331

br_to = Branch.open_containing('.')

332

stored_loc = br_to.get_parent()

333

if location is None:

334

if stored_loc is None:

335

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

336

else:

337

print "Using last location: %s" % stored_loc

338

location = stored_loc

339

cache_root = tempfile.mkdtemp()

340

from bzrlib.errors import DivergedBranches

341

br_from = Branch.open_containing(location)

342

location = br_from.base

343

old_revno = br_to.revno()

344

try:

345

from bzrlib.errors import DivergedBranches

346

br_from = Branch.open(location)

347

br_from.setup_caching(cache_root)

348

location = br_from.base

349

old_revno = br_to.revno()

350

try:

351

br_to.update_revisions(br_from)

352

except DivergedBranches:

353

raise BzrCommandError("These branches have diverged."

354

" Try merge.")

355

356

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

357

if location != stored_loc:

358

br_to.set_parent(location)

359

finally:

360

rmtree(cache_root)

361

362

363

364

class cmd_branch(Command):

365

"""Create a new copy of a branch.

366

367

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

368

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

369

370

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

371

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

372

"""

373

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

374

takes_options = ['revision']

375

aliases = ['get', 'clone']

376

377

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

378

from bzrlib.branch import copy_branch

379

import tempfile

380

import errno

381

from shutil import rmtree

382

cache_root = tempfile.mkdtemp()

383

try:

384

if revision is None:

385

revision = [None]

386

elif len(revision) > 1:

387

raise BzrCommandError(

388

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

389

try:

390

br_from = Branch.open(from_location)

391

except OSError, e:

392

if e.errno == errno.ENOENT:

393

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

394

' exist.' % to_location)

395

else:

396

raise

397

br_from.setup_caching(cache_root)

398

if to_location is None:

399

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

400

try:

401

os.mkdir(to_location)

402

except OSError, e:

403

if e.errno == errno.EEXIST:

404

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

405

' exists.' % to_location)

406

if e.errno == errno.ENOENT:

407

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

408

to_location)

409

else:

410

raise

411

try:

412

copy_branch(br_from, to_location, revision[0])

413

except bzrlib.errors.NoSuchRevision:

414

rmtree(to_location)

415

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

416

raise BzrCommandError(msg)

417

finally:

418

rmtree(cache_root)

419

420

421

class cmd_renames(Command):

422

"""Show list of renamed files.

423

424

TODO: Option to show renames between two historical versions.

425

426

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

427

"""

428

takes_args = ['dir?']

429

430

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

431

b = Branch.open_containing(dir)

432

old_inv = b.basis_tree().inventory

433

new_inv = b.read_working_inventory()

434

435

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

436

renames.sort()

437

for old_name, new_name in renames:

438

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

439

440

441

class cmd_info(Command):

442

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

443

takes_args = ['branch?']

444

445

def run(self, branch=None):

446

import info

447

448

b = Branch.open_containing(branch)

449

info.show_info(b)

450

451

452

class cmd_remove(Command):

453

"""Make a file unversioned.

454

455

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

456

not delete the working copy.

457

"""

458

takes_args = ['file+']

459

takes_options = ['verbose']

460

461

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

462

b = Branch.open_containing(file_list[0])

463

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

464

465

466

class cmd_file_id(Command):

467

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

468

469

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

470

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

471

moved or renamed.

472

"""

473

hidden = True

474

takes_args = ['filename']

475

def run(self, filename):

476

b = Branch.open_containing(filename)

477

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

478

if i == None:

479

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

480

else:

481

print i

482

483

484

class cmd_file_path(Command):

485

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

486

487

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

488

starting at the branch root."""

489

hidden = True

490

takes_args = ['filename']

491

def run(self, filename):

492

b = Branch.open_containing(filename)

493

inv = b.inventory

494

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

495

if fid == None:

496

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

497

for fip in inv.get_idpath(fid):

498

print fip

499

500

501

class cmd_revision_history(Command):

502

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

503

hidden = True

504

def run(self):

505

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

506

print patchid

507

508

509

class cmd_directories(Command):

510

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

511

def run(self):

512

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

513

if name == '':

514

print '.'

515

else:

516

print name

517

518

519

class cmd_init(Command):

520

"""Make a directory into a versioned branch.

521

522

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

523

existing project.

524

525

Recipe for importing a tree of files:

526

cd ~/project

527

bzr init

528

bzr add -v .

529

bzr status

530

bzr commit -m 'imported project'

531

"""

532

def run(self):

533

from bzrlib.branch import Branch

534

Branch.initialize('.')

535

536

537

class cmd_diff(Command):

538

"""Show differences in working tree.

539

540

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

541

Otherwise, all changes for the tree are listed.

542

543

TODO: Allow diff across branches.

544

545

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

546

or a graphical diff.

547

548

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

549

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

550

551

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

552

553

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

554

deleted files.

555

556

TODO: This probably handles non-Unix newlines poorly.

557

558

examples:

559

bzr diff

560

bzr diff -r1

561

bzr diff -r1..2

562

"""

563

564

takes_args = ['file*']

565

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

566

aliases = ['di', 'dif']

567

568

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

569

from bzrlib.diff import show_diff

570

571

if file_list:

572

b = Branch.open_containing(file_list[0])

573

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

574

if file_list == ['']:

575

# just pointing to top-of-tree

576

file_list = None

577

else:

578

b = Branch.open_containing('.')

579

580

if revision is not None:

581

if len(revision) == 1:

582

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

583

external_diff_options=diff_options)

584

elif len(revision) == 2:

585

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

586

external_diff_options=diff_options,

587

revision2=revision[1])

588

else:

589

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

590

else:

591

show_diff(b, None, specific_files=file_list,

592

external_diff_options=diff_options)

593

594

595

596

597

class cmd_deleted(Command):

598

"""List files deleted in the working tree.

599

600

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

601

"""

602

def run(self, show_ids=False):

603

b = Branch.open_containing('.')

604

old = b.basis_tree()

605

new = b.working_tree()

606

607

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

608

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

609

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

610

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

611

612

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

613

if not new.has_id(ie.file_id):

614

if show_ids:

615

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

616

else:

617

print path

618

619

620

class cmd_modified(Command):

621

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

622

hidden = True

623

def run(self):

624

from bzrlib.delta import compare_trees

625

626

b = Branch.open_containing('.')

627

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

628

629

for path, id, kind in td.modified:

630

print path

631

632

633

634

class cmd_added(Command):

635

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

636

hidden = True

637

def run(self):

638

b = Branch.open_containing('.')

639

wt = b.working_tree()

640

basis_inv = b.basis_tree().inventory

641

inv = wt.inventory

642

for file_id in inv:

643

if file_id in basis_inv:

644

continue

645

path = inv.id2path(file_id)

646

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

647

continue

648

print path

649

650

651

652

class cmd_root(Command):

653

"""Show the tree root directory.

654

655

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

656

directory."""

657

takes_args = ['filename?']

658

def run(self, filename=None):

659

"""Print the branch root."""

660

b = Branch.open_containing(filename)

661

print b.base

662

663

664

class cmd_log(Command):

665

"""Show log of this branch.

666

667

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

668

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

669

also valid.

670

671

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

672

so that only matching entries will be displayed.

673

674

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

675

676

"""

677

678

takes_args = ['filename?']

679

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

680

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

681

682

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

683

verbose=False,

684

show_ids=False,

685

forward=False,

686

revision=None,

687

message=None,

688

long=False,

689

short=False):

690

from bzrlib.log import log_formatter, show_log

691

import codecs

692

693

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

694

695

if filename:

696

b = Branch.open_containing(filename)

697

fp = b.relpath(filename)

698

if fp:

699

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

700

else:

701

file_id = None # points to branch root

702

else:

703

b = Branch.open_containing('.')

704

file_id = None

705

706

if revision is None:

707

rev1 = None

708

rev2 = None

709

elif len(revision) == 1:

710

rev1 = rev2 = revision[0].in_history(b).revno

711

elif len(revision) == 2:

712

rev1 = revision[0].in_history(b).revno

713

rev2 = revision[1].in_history(b).revno

714

else:

715

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

716

717

if rev1 == 0:

718

rev1 = None

719

if rev2 == 0:

720

rev2 = None

721

722

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

723

724

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

725

# in e.g. the default C locale.

726

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

727

728

if not short:

729

log_format = 'long'

730

else:

731

log_format = 'short'

732

lf = log_formatter(log_format,

733

show_ids=show_ids,

734

to_file=outf,

735

show_timezone=timezone)

736

737

show_log(b,

738

lf,

739

file_id,

740

verbose=verbose,

741

direction=direction,

742

start_revision=rev1,

743

end_revision=rev2,

744

search=message)

745

746

747

748

class cmd_touching_revisions(Command):

749

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

750

751

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

752

hidden = True

753

takes_args = ["filename"]

754

def run(self, filename):

755

b = Branch.open_containing(filename)

756

inv = b.read_working_inventory()

757

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

758

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

759

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

760

761

762

class cmd_ls(Command):

763

"""List files in a tree.

764

765

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

766

"""

767

hidden = True

768

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

769

b = Branch.open_containing('.')

770

if revision == None:

771

tree = b.working_tree()

772

else:

773

tree = b.revision_tree(revision.in_history(b).rev_id)

774

775

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

776

if verbose:

777

if kind == 'directory':

778

kindch = '/'

779

elif kind == 'file':

780

kindch = ''

781

else:

782

kindch = '???'

783

784

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

785

else:

786

print fp

787

788

789

790

class cmd_unknowns(Command):

791

"""List unknown files."""

792

def run(self):

793

from bzrlib.osutils import quotefn

794

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

795

print quotefn(f)

796

797

798

799

class cmd_ignore(Command):

800

"""Ignore a command or pattern.

801

802

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

803

804

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

805

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

806

component of the path.

807

808

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

809

810

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

811

812

examples:

813

bzr ignore ./Makefile

814

bzr ignore '*.class'

815

"""

816

takes_args = ['name_pattern']

817

818

def run(self, name_pattern):

819

from bzrlib.atomicfile import AtomicFile

820

import os.path

821

822

b = Branch.open_containing('.')

823

ifn = b.abspath('.bzrignore')

824

825

if os.path.exists(ifn):

826

f = open(ifn, 'rt')

827

try:

828

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

829

finally:

830

f.close()

831

else:

832

igns = ''

833

834

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

835

# we should use that for the newly added lines?

836

837

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

838

igns += '\n'

839

igns += name_pattern + '\n'

840

841

try:

842

f = AtomicFile(ifn, 'wt')

843

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

844

f.commit()

845

finally:

846

f.close()

847

848

inv = b.working_tree().inventory

849

if inv.path2id('.bzrignore'):

850

mutter('.bzrignore is already versioned')

851

else:

852

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

853

b.add(['.bzrignore'])

854

855

856

857

class cmd_ignored(Command):

858

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

859

860