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

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

If a revision argument is given, the status is calculated against

67

that revision, or between two revisions if two are provided.

68

"""

69

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

70

# relative to a revision, or between revisions

71

72

takes_args = ['file*']

73

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

74

aliases = ['st', 'stat']

75

76

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

77

if file_list:

78

b = Branch.open_containing(file_list[0])

79

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

80

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

81

# of the branch

82

if file_list == ['']:

83

file_list = None

84

else:

85

b = Branch.open_containing('.')

86

87

from bzrlib.status import show_status

88

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

89

specific_files=file_list, revision=revision)

90

91

92

class cmd_cat_revision(Command):

93

"""Write out metadata for a revision.

94

95

The revision to print can either be specified by a specific

96

revision identifier, or you can use --revision.

97

"""

98

99

hidden = True

100

takes_args = ['revision_id?']

101

takes_options = ['revision']

102

103

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

104

from bzrlib.revisionspec import RevisionSpec

105

106

if revision_id is not None and revision is not None:

107

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

108

if revision_id is None and revision is None:

109

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

110

b = Branch.open_containing('.')

111

if revision_id is not None:

112

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

113

elif revision is not None:

114

for rev in revision:

115

if rev is None:

116

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

117

revno, rev_id = rev.in_history(b)

118

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

119

120

121

class cmd_revno(Command):

122

"""Show current revision number.

123

124

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

125

def run(self):

126

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

127

128

129

class cmd_revision_info(Command):

130

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

131

"""

132

hidden = True

133

takes_args = ['revision_info*']

134

takes_options = ['revision']

135

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

136

from bzrlib.revisionspec import RevisionSpec

137

138

revs = []

139

if revision is not None:

140

revs.extend(revision)

141

if revision_info_list is not None:

142

for rev in revision_info_list:

143

revs.append(RevisionSpec(rev))

144

if len(revs) == 0:

145

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

146

147

b = Branch.open_containing('.')

148

149

for rev in revs:

150

revinfo = rev.in_history(b)

151

if revinfo.revno is None:

152

print ' %s' % revinfo.rev_id

153

else:

154

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

155

156

157

class cmd_add(Command):

158

"""Add specified files or directories.

159

160

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

161

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

162

any of the named files are already versioned.

163

164

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

165

but the behaviour for directories is different. Directories that

166

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

167

whether already versioned or not, are searched for files or

168

subdirectories that are neither versioned or ignored, and these

169

are added. This search proceeds recursively into versioned

170

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

171

172

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

173

are currently unknown.

174

175

Adding a file whose parent directory is not versioned will

176

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

177

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

178

get added when you add a file in the directory.

179

"""

180

takes_args = ['file*']

181

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

182

183

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

184

# verbose currently has no effect

185

from bzrlib.add import smart_add, add_reporter_print

186

smart_add(file_list, not no_recurse, add_reporter_print)

187

188

189

190

class cmd_mkdir(Command):

191

"""Create a new versioned directory.

192

193

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

194

"""

195

takes_args = ['dir+']

196

197

def run(self, dir_list):

198

b = None

199

200

for d in dir_list:

201

os.mkdir(d)

202

if not b:

203

b = Branch.open_containing(d)

204

b.add([d])

205

print 'added', d

206

207

208

class cmd_relpath(Command):

209

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

210

takes_args = ['filename']

211

hidden = True

212

213

def run(self, filename):

214

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

215

216

217

218

class cmd_inventory(Command):

219

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

220

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

221

222

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

223

b = Branch.open_containing('.')

224

if revision is None:

225

inv = b.read_working_inventory()

226

else:

227

if len(revision) > 1:

228

raise BzrCommandError('bzr inventory --revision takes'

229

' exactly one revision identifier')

230

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

231

232

for path, entry in inv.entries():

233

if show_ids:

234

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

235

else:

236

print path

237

238

239

class cmd_move(Command):

240

"""Move files to a different directory.

241

242

examples:

243

bzr move *.txt doc

244

245

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

246

"""

247

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

248

def run(self, source_list, dest):

249

b = Branch.open_containing('.')

250

251

# TODO: glob expansion on windows?

252

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

253

254

255

class cmd_rename(Command):

256

"""Change the name of an entry.

257

258

examples:

259

bzr rename frob.c frobber.c

260

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

261

262

It is an error if the destination name exists.

263

264

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

265

directory without changing their name.

266

267

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

268

one?"""

269

takes_args = ['from_name', 'to_name']

270

271

def run(self, from_name, to_name):

272

b = Branch.open_containing('.')

273

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

274

275

276

277

class cmd_mv(Command):

278

"""Move or rename a file.

279

280

usage:

281

bzr mv OLDNAME NEWNAME

282

bzr mv SOURCE... DESTINATION

283

284

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

285

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

286

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

287

288

Files cannot be moved between branches.

289

"""

290

takes_args = ['names*']

291

def run(self, names_list):

292

if len(names_list) < 2:

293

raise BzrCommandError("missing file argument")

294

b = Branch.open_containing(names_list[0])

295

296

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

297

298

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

299

# move into existing directory

300

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

301

print "%s => %s" % pair

302

else:

303

if len(names_list) != 2:

304

raise BzrCommandError('to mv multiple files the destination '

305

'must be a versioned directory')

306

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

307

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

308

309

310

311

312

class cmd_pull(Command):

313

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

314

315

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

316

Both the revision history and the working directory will be

317

updated.

318

319

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

320

considered diverged if both branches have had commits without first

321

pulling from the other.

322

323

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

324

from one into the other.

325

"""

326

takes_args = ['location?']

327

328

def run(self, location=None):

329

from bzrlib.merge import merge

330

import tempfile

331

from shutil import rmtree

332

import errno

333

334

br_to = Branch.open_containing('.')

335

stored_loc = br_to.get_parent()

336

if location is None:

337

if stored_loc is None:

338

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

339

else:

340

print "Using last location: %s" % stored_loc

341

location = stored_loc

342

cache_root = tempfile.mkdtemp()

343

from bzrlib.errors import DivergedBranches

344

br_from = Branch.open_containing(location)

345

location = br_from.base

346

old_revno = br_to.revno()

347

try:

348

from bzrlib.errors import DivergedBranches

349

br_from = Branch.open(location)

350

br_from.setup_caching(cache_root)

351

location = br_from.base

352

old_revno = br_to.revno()

353

try:

354

br_to.update_revisions(br_from)

355

except DivergedBranches:

356

raise BzrCommandError("These branches have diverged."

357

" Try merge.")

358

359

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

360

if location != stored_loc:

361

br_to.set_parent(location)

362

finally:

363

rmtree(cache_root)

364

365

366

367

class cmd_branch(Command):

368

"""Create a new copy of a branch.

369

370

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

371

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

372

373

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

374

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

375

376

--basis is to speed up branching from remote branches. When specified, it

377

copies all the file-contents, inventory and revision data from the basis

378

branch before copying anything from the remote branch.

379

"""

380

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

381

takes_options = ['revision', 'basis']

382

aliases = ['get', 'clone']

383

384

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

385

from bzrlib.branch import copy_branch

386

import tempfile

387

import errno

388

from shutil import rmtree

389

cache_root = tempfile.mkdtemp()

390

try:

391

if revision is None:

392

revision = [None]

393

elif len(revision) > 1:

394

raise BzrCommandError(

395

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

396

try:

397

br_from = Branch.open(from_location)

398

except OSError, e:

399

if e.errno == errno.ENOENT:

400

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

401

' exist.' % to_location)

402

else:

403

raise

404

br_from.setup_caching(cache_root)

405

if basis is not None:

406

basis_branch = Branch.open_containing(basis)

407

else:

408

basis_branch = None

409

if len(revision) == 1 and revision[0] is not None:

410

revno = revision[0].in_history(br_from)[0]

411

else:

412

revno = None

413

if to_location is None:

414

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

415

try:

416

os.mkdir(to_location)

417

except OSError, e:

418

if e.errno == errno.EEXIST:

419

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

420

' exists.' % to_location)

421

if e.errno == errno.ENOENT:

422

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

423

to_location)

424

else:

425

raise

426

try:

427

copy_branch(br_from, to_location, revno, basis_branch)

428

except bzrlib.errors.NoSuchRevision:

429

rmtree(to_location)

430

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

431

raise BzrCommandError(msg)

432

except bzrlib.errors.UnlistableBranch:

433

msg = "The branch %s cannot be used as a --basis"

434

finally:

435

rmtree(cache_root)

436

437

438

class cmd_renames(Command):

439

"""Show list of renamed files.

440

441

TODO: Option to show renames between two historical versions.

442

443

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

444

"""

445

takes_args = ['dir?']

446

447

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

448

b = Branch.open_containing(dir)

449

old_inv = b.basis_tree().inventory

450

new_inv = b.read_working_inventory()

451

452

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

453

renames.sort()

454

for old_name, new_name in renames:

455

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

456

457

458

class cmd_info(Command):

459

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

460

takes_args = ['branch?']

461

462

def run(self, branch=None):

463

import info

464

465

b = Branch.open_containing(branch)

466

info.show_info(b)

467

468

469

class cmd_remove(Command):

470

"""Make a file unversioned.

471

472

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

473

not delete the working copy.

474

"""

475

takes_args = ['file+']

476

takes_options = ['verbose']

477

478

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

479

b = Branch.open_containing(file_list[0])

480

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

481

482

483

class cmd_file_id(Command):

484

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

485

486

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

487

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

488

moved or renamed.

489

"""

490

hidden = True

491

takes_args = ['filename']

492

def run(self, filename):

493

b = Branch.open_containing(filename)

494

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

495

if i == None:

496

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

497

else:

498

print i

499

500

501

class cmd_file_path(Command):

502

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

503

504

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

505

starting at the branch root."""

506

hidden = True

507

takes_args = ['filename']

508

def run(self, filename):

509

b = Branch.open_containing(filename)

510

inv = b.inventory

511

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

512

if fid == None:

513

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

514

for fip in inv.get_idpath(fid):

515

print fip

516

517

518

class cmd_revision_history(Command):

519

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

520

hidden = True

521

def run(self):

522

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

523

print patchid

524

525

526

class cmd_directories(Command):

527

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

528

def run(self):

529

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

530

if name == '':

531

print '.'

532

else:

533

print name

534

535

536

class cmd_init(Command):

537

"""Make a directory into a versioned branch.

538

539

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

540

existing project.

541

542

Recipe for importing a tree of files:

543

cd ~/project

544

bzr init

545

bzr add -v .

546

bzr status

547

bzr commit -m 'imported project'

548

"""

549

def run(self):

550

from bzrlib.branch import Branch

551

Branch.initialize('.')

552

553

554

class cmd_diff(Command):

555

"""Show differences in working tree.

556

557

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

558

Otherwise, all changes for the tree are listed.

559

560

TODO: Allow diff across branches.

561

562

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

563

or a graphical diff.

564

565

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

566

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

567

568

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

569

570

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

571

deleted files.

572

573

TODO: This probably handles non-Unix newlines poorly.

574

575

examples:

576

bzr diff

577

bzr diff -r1

578

bzr diff -r1..2

579

"""

580

581

takes_args = ['file*']

582

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

583

aliases = ['di', 'dif']

584

585

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

586

from bzrlib.diff import show_diff

587

588

if file_list:

589

b = Branch.open_containing(file_list[0])

590

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

591

if file_list == ['']:

592

# just pointing to top-of-tree

593

file_list = None

594

else:

595

b = Branch.open_containing('.')

596

597

if revision is not None:

598

if len(revision) == 1:

599

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

600

external_diff_options=diff_options)

601

elif len(revision) == 2:

602

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

603

external_diff_options=diff_options,

604

revision2=revision[1])

605

else:

606

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

607

else:

608

show_diff(b, None, specific_files=file_list,

609

external_diff_options=diff_options)

610

611

612

613

614

class cmd_deleted(Command):

615

"""List files deleted in the working tree.

616

617

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

618

"""

619

def run(self, show_ids=False):

620

b = Branch.open_containing('.')

621

old = b.basis_tree()

622

new = b.working_tree()

623

624

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

625

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

626

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

627

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

628

629

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

630

if not new.has_id(ie.file_id):

631

if show_ids:

632

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

633

else:

634

print path

635

636

637

class cmd_modified(Command):

638

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

639

hidden = True

640

def run(self):

641

from bzrlib.delta import compare_trees

642

643

b = Branch.open_containing('.')

644

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

645

646

for path, id, kind in td.modified:

647

print path

648

649

650

651

class cmd_added(Command):

652

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

653

hidden = True

654

def run(self):

655

b = Branch.open_containing('.')

656

wt = b.working_tree()

657

basis_inv = b.basis_tree().inventory

658

inv = wt.inventory

659

for file_id in inv:

660

if file_id in basis_inv:

661

continue

662

path = inv.id2path(file_id)

663

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

664

continue

665

print path

666

667

668

669

class cmd_root(Command):

670

"""Show the tree root directory.

671

672

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

673

directory."""

674

takes_args = ['filename?']

675

def run(self, filename=None):

676

"""Print the branch root."""

677

b = Branch.open_containing(filename)

678

print b.base

679

680

681

class cmd_log(Command):

682

"""Show log of this branch.

683

684

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

685

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

686

also valid.

687

688

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

689

so that only matching entries will be displayed.

690

691

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

692

693

"""

694

695

takes_args = ['filename?']

696

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

697

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

698

699

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

700

verbose=False,

701

show_ids=False,

702

forward=False,

703

revision=None,

704

message=None,

705

long=False,

706

short=False):

707

from bzrlib.log import log_formatter, show_log

708

import codecs

709

710

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

711

712

if filename:

713

b = Branch.open_containing(filename)

714

fp = b.relpath(filename)

715

if fp:

716

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

717

else:

718

file_id = None # points to branch root

719

else:

720

b = Branch.open_containing('.')

721

file_id = None

722

723

if revision is None:

724

rev1 = None

725

rev2 = None

726

elif len(revision) == 1:

727

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

728

elif len(revision) == 2:

729

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

730

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

731

else:

732

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

733

734

if rev1 == 0:

735

rev1 = None

736

if rev2 == 0:

737

rev2 = None

738

739

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

740

741

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

742

# in e.g. the default C locale.

743

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

744

745

if not short:

746

log_format = 'long'

747

else:

748

log_format = 'short'

749

lf = log_formatter(log_format,

750

show_ids=show_ids,

751

to_file=outf,

752

show_timezone=timezone)

753

754

show_log(b,

755

lf,

756

file_id,

757

verbose=verbose,

758

direction=direction,

759

start_revision=rev1,

760

end_revision=rev2,

761

search=message)

762

763

764

765

class cmd_touching_revisions(Command):

766

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

767

768

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

769

hidden = True

770

takes_args = ["filename"]

771

def run(self, filename):

772

b = Branch.open_containing(filename)

773

inv = b.read_working_inventory()

774

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

775

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

776

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

777

778

779

class cmd_ls(Command):

780

"""List files in a tree.

781

782

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

783

"""

784

hidden = True

785

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

786

b = Branch.open_containing('.')

787

if revision == None:

788

tree = b.working_tree()

789

else:

790

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

791

792

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

793

if verbose:

794

if kind == 'directory':

795

kindch = '/'

796

elif kind == 'file':

797

kindch = ''

798

else:

799

kindch = '???'

800

801

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

802

else:

803

print fp

804

805

806

807

class cmd_unknowns(Command):

808

"""List unknown files."""

809

def run(self):

810

from bzrlib.osutils import quotefn

811

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

812

print quotefn(f)

813

814

815

816

class cmd_ignore(Command):

817

"""Ignore a command or pattern.

818

819

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

820

821

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

822

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

823

component of the path.

824

825

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

826

827

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

828

829

examples:

830

bzr ignore ./Makefile

831

bzr ignore '*.class'

832

"""

833

takes_args = ['name_pattern']

834

835

def run(self, name_pattern):

836

from bzrlib.atomicfile import AtomicFile

837

import os.path

838

839

b = Branch.open_containing('.')

840

ifn = b.abspath('.bzrignore')

841

842

if os.path.exists(ifn):

843

f = open(ifn, 'rt')

844

try:

845

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

846

finally:

847

f.close()

848

else:

849

igns = ''

850

851

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

852

# we should use that for the newly added lines?

853

854

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

855

igns += '\n'

856

igns += name_pattern + '\n'

857

858

try:

859

f = AtomicFile(ifn, 'wt')

860

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

861

f.commit()

862

finally:

863

f.close()

864

865

inv = b.working_tree().inventory

866

if inv.path2id('.bzrignore'):

867

mutter('.bzrignore is already versioned')

868

else:

869

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

870

b.add(['.bzrignore'])

871

872

873

874

class cmd_ignored(Command):

875

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

876

877