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

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

14

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

15

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

16

17

# TODO: Move this into builtins

18

19

17

# TODO: 'bzr resolve' should accept a directory name and work from that

20

18

# point down

21

19

22

20

import os

21

import re

23

22

24

23

from bzrlib.lazy_import import lazy_import

25

24

lazy_import(globals(), """

32

31

osutils,

33

32

rio,

34

33

trace,

34

transform,

35

workingtree,

35

36

)

36

37

""")

37

from bzrlib.option import Option

38

from bzrlib import (

39

option,

40

registry,

41

)

38

42

39

43

40

44

CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')

55

59

Use bzr resolve when you have fixed a problem.

56

60

"""

57

61

takes_options = [

58

Option('text',

59

help='List paths of files with text conflicts.'),

62

option.Option('text',

63

help='List paths of files with text conflicts.'),

60

64

]

61

65

_see_also = ['resolve', 'conflict-types']

62

66

63

67

def run(self, text=False):

64

from bzrlib.workingtree import WorkingTree

65

wt = WorkingTree.open_containing(u'.')[0]

68

wt = workingtree.WorkingTree.open_containing(u'.')[0]

66

69

for conflict in wt.conflicts():

67

70

if text:

68

71

if conflict.typestring != 'text conflict':

72

75

self.outf.write(str(conflict) + '\n')

73

76

74

77

78

resolve_action_registry = registry.Registry()

79

80

81

resolve_action_registry.register(

82

'done', 'done', 'Marks the conflict as resolved' )

83

resolve_action_registry.register(

84

'take-this', 'take_this',

85

'Resolve the conflict preserving the version in the working tree' )

86

resolve_action_registry.register(

87

'take-other', 'take_other',

88

'Resolve the conflict taking the merged version into account' )

89

resolve_action_registry.default_key = 'done'

90

91

class ResolveActionOption(option.RegistryOption):

92

93

def __init__(self):

94

super(ResolveActionOption, self).__init__(

95

'action', 'How to resolve the conflict.',

96

value_switches=True,

97

registry=resolve_action_registry)

98

99

75

100

class cmd_resolve(commands.Command):

76

101

"""Mark a conflict as resolved.

77

102

87

112

aliases = ['resolved']

88

113

takes_args = ['file*']

89

114

takes_options = [

90

Option('all', help='Resolve all conflicts in this tree.'),

115

option.Option('all', help='Resolve all conflicts in this tree.'),

116

ResolveActionOption(),

91

117

]

92

118

_see_also = ['conflicts']

93

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

94

from bzrlib.workingtree import WorkingTree

119

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

95

120

if all:

96

121

if file_list:

97

122

raise errors.BzrCommandError("If --all is specified,"

98

123

" no FILE may be provided")

99

tree = WorkingTree.open_containing('.')[0]

100

resolve(tree)

124

tree = workingtree.WorkingTree.open_containing('.')[0]

125

if action is None:

126

action = 'done'

101

127

else:

102

128

tree, file_list = builtins.tree_files(file_list)

103

129

if file_list is None:

130

if action is None:

131

# FIXME: There is a special case here related to the option

132

# handling that could be clearer and easier to discover by

133

# providing an --auto action (bug #344013 and #383396) and

134

# make it mandatory instead of implicit and active only

135

# when no file_list is provided -- vila 091229

136

action = 'auto'

137

else:

138

if action is None:

139

action = 'done'

140

if action == 'auto':

141

if file_list is None:

104

142

un_resolved, resolved = tree.auto_resolve()

105

143

if len(un_resolved) > 0:

106

144

trace.note('%d conflict(s) auto-resolved.', len(resolved))

112

150

trace.note('All conflicts resolved.')

113

151

return 0

114

152

else:

115

resolve(tree, file_list)

116

117

118

def resolve(tree, paths=None, ignore_misses=False, recursive=False):

153

# FIXME: This can never occur but the block above needs some

154

# refactoring to transfer tree.auto_resolve() to

155

# conflict.auto(tree) --vila 091242

156

pass

157

else:

158

resolve(tree, file_list, action=action)

159

160

161

def resolve(tree, paths=None, ignore_misses=False, recursive=False,

162

action='done'):

119

163

"""Resolve some or all of the conflicts in a working tree.

120

164

121

165

:param paths: If None, resolve all conflicts. Otherwise, select only

125

169

recursive commands like revert, this should be True. For commands

126

170

or applications wishing finer-grained control, like the resolve

127

171

command, this should be False.

128

:ignore_misses: If False, warnings will be printed if the supplied paths

129

do not have conflicts.

172

:param ignore_misses: If False, warnings will be printed if the supplied

173

paths do not have conflicts.

174

:param action: How the conflict should be resolved,

130

175

"""

131

176

tree.lock_tree_write()

132

177

try:

133

178

tree_conflicts = tree.conflicts()

134

179

if paths is None:

135

180

new_conflicts = ConflictList()

136

selected_conflicts = tree_conflicts

181

to_process = tree_conflicts

137

182

else:

138

new_conflicts, selected_conflicts = \

139

tree_conflicts.select_conflicts(tree, paths, ignore_misses,

140

recursive)

183

new_conflicts, to_process = tree_conflicts.select_conflicts(

184

tree, paths, ignore_misses, recursive)

185

for conflict in to_process:

186

try:

187

conflict._do(action, tree)

188

conflict.cleanup(tree)

189

except NotImplementedError:

190

new_conflicts.append(conflict)

141

191

try:

142

192

tree.set_conflicts(new_conflicts)

143

193

except errors.UnsupportedOperation:

144

194

pass

145

selected_conflicts.remove_files(tree)

146

195

finally:

147

196

tree.unlock()

148

197

237

286

for conflict in self:

238

287

if not conflict.has_files:

239

288

continue

240

for suffix in CONFLICT_SUFFIXES:

241

try:

242

osutils.delete_any(tree.abspath(conflict.path+suffix))

243

except OSError, e:

244

if e.errno != errno.ENOENT:

245

raise

289

conflict.cleanup(tree)

246

290

247

291

def select_conflicts(self, tree, paths, ignore_misses=False,

248

292

recurse=False):

301

345

class Conflict(object):

302

346

"""Base class for all types of conflict"""

303

347

348

# FIXME: cleanup should take care of that ? -- vila 091229

304

349

has_files = False

305

350

306

351

def __init__(self, path, file_id=None):

355

400

else:

356

401

return None, conflict.typestring

357

402

403

def _do(self, action, tree):

404

"""Apply the specified action to the conflict.

405

406

:param action: The method name to call.

407

408

:param tree: The tree passed as a parameter to the method.

409

"""

410

meth = getattr(self, 'action_%s' % action, None)

411

if meth is None:

412

raise NotImplementedError(self.__class__.__name__ + '.' + action)

413

meth(tree)

414

415

def cleanup(self, tree):

416

raise NotImplementedError(self.cleanup)

417

418

def action_done(self, tree):

419

"""Mark the conflict as solved once it has been handled."""

420

# This method does nothing but simplifies the design of upper levels.

421

pass

422

423

def action_take_this(self, tree):

424

raise NotImplementedError(self.action_take_this)

425

426

def action_take_other(self, tree):

427

raise NotImplementedError(self.action_take_other)

428

358

429

359

430

class PathConflict(Conflict):

360

431

"""A conflict was encountered merging file paths"""

364

435

format = 'Path conflict: %(path)s / %(conflict_path)s'

365

436

366

437

rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'

438

367

439

def __init__(self, path, conflict_path=None, file_id=None):

368

440

Conflict.__init__(self, path, file_id)

369

441

self.conflict_path = conflict_path

374

446

s.add('conflict_path', self.conflict_path)

375

447

return s

376

448

449

def cleanup(self, tree):

450

# No additional files have been generated here

451

pass

452

453

def action_take_this(self, tree):

454

tree.rename_one(self.conflict_path, self.path)

455

456

def action_take_other(self, tree):

457

# just acccept bzr proposal

458

pass

459

377

460

378

461

class ContentsConflict(PathConflict):

379

462

"""The files are of different types, or not present"""

384

467

385

468

format = 'Contents conflict in %(path)s'

386

469

387

470

def cleanup(self, tree):

471

for suffix in ('.BASE', '.OTHER'):

472

try:

473

osutils.delete_any(tree.abspath(self.path + suffix))

474

except OSError, e:

475

if e.errno != errno.ENOENT:

476

raise

477

478

# FIXME: I smell something weird here and it seems we should be able to be

479

# more coherent with some other conflict ? bzr *did* a choice there but

480

# neither action_take_this nor action_take_other reflect that...

481

# -- vila 20091224

482

def action_take_this(self, tree):

483

tree.remove([self.path + '.OTHER'], force=True, keep_files=False)

484

485

def action_take_other(self, tree):

486

tree.remove([self.path], force=True, keep_files=False)

487

488

489

490

# FIXME: TextConflict is about a single file-id, there never is a conflict_path

491

# attribute so we shouldn't inherit from PathConflict but simply from Conflict

492

493

# TODO: There should be a base revid attribute to better inform the user about

494

# how the conflicts were generated.

388

495

class TextConflict(PathConflict):

389

496

"""The merge algorithm could not resolve all differences encountered."""

390

497

394

501

395

502

format = 'Text conflict in %(path)s'

396

503

504

def cleanup(self, tree):

505

for suffix in CONFLICT_SUFFIXES:

506

try:

507

osutils.delete_any(tree.abspath(self.path+suffix))

508

except OSError, e:

509

if e.errno != errno.ENOENT:

510

raise

511

397

512

398

513

class HandledConflict(Conflict):

399

514

"""A path problem that has been provisionally resolved.

414

529

s.add('action', self.action)

415

530

return s

416

531

532

def cleanup(self, tree):

533

"""Nothing to cleanup."""

534

pass

535

417

536

418

537

class HandledPathConflict(HandledConflict):

419

538

"""A provisionally-resolved path problem involving two paths.

460

579

461

580

format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'

462

581

582

def action_take_this(self, tree):

583

tree.remove([self.conflict_path], force=True, keep_files=False)

584

tree.rename_one(self.path, self.conflict_path)

585

586

def action_take_other(self, tree):

587

tree.remove([self.path], force=True, keep_files=False)

588

463

589

464

590

class ParentLoop(HandledPathConflict):

465

591

"""An attempt to create an infinitely-looping directory structure.

466

592

This is rare, but can be produced like so:

467

593

468

594

tree A:

469

mv foo/bar

595

mv foo bar

470

596

tree B:

471

mv bar/foo

597

mv bar foo

472

598

merge A and B

473

599

"""

474

600

476

602

477

603

format = 'Conflict moving %(conflict_path)s into %(path)s. %(action)s.'

478

604

605

def action_take_this(self, tree):

606

# just acccept bzr proposal

607

pass

608

609

def action_take_other(self, tree):

610

# FIXME: We shouldn't have to manipulate so many paths here (and there

611

# is probably a bug or two...)

612

base_path = osutils.basename(self.path)

613

conflict_base_path = osutils.basename(self.conflict_path)

614

tt = transform.TreeTransform(tree)

615

try:

616

p_tid = tt.trans_id_file_id(self.file_id)

617

parent_tid = tt.get_tree_parent(p_tid)

618

cp_tid = tt.trans_id_file_id(self.conflict_file_id)

619

cparent_tid = tt.get_tree_parent(cp_tid)

620

tt.adjust_path(base_path, cparent_tid, cp_tid)

621

tt.adjust_path(conflict_base_path, parent_tid, p_tid)

622

tt.apply()

623

finally:

624

tt.finalize()

625

479

626

480

627

class UnversionedParent(HandledConflict):

481

628

"""An attempt to version a file whose parent directory is not versioned.

488

635

format = 'Conflict because %(path)s is not versioned, but has versioned'\

489

636

' children. %(action)s.'

490

637

638

# FIXME: We silently do nothing to make tests pass, but most probably the

639

# conflict shouldn't exist (the long story is that the conflict is

640

# generated with another one that can be resolved properly) -- vila 091224

641

def action_take_this(self, tree):

642

pass

643

644

def action_take_other(self, tree):

645

pass

646

491

647

492

648

class MissingParent(HandledConflict):

493

649

"""An attempt to add files to a directory that is not present.

494

650

Typically, the result of a merge where THIS deleted the directory and

495

651

the OTHER added a file to it.

496

See also: DeletingParent (same situation, reversed THIS and OTHER)

652

See also: DeletingParent (same situation, THIS and OTHER reversed)

497

653

"""

498

654

499

655

typestring = 'missing parent'

500

656

501

657

format = 'Conflict adding files to %(path)s. %(action)s.'

502

658

659

def action_take_this(self, tree):

660

tree.remove([self.path], force=True, keep_files=False)

661

662

def action_take_other(self, tree):

663

# just acccept bzr proposal

664

pass

665

503

666

504

667

class DeletingParent(HandledConflict):

505

668

"""An attempt to add files to a directory that is not present.

512

675

format = "Conflict: can't delete %(path)s because it is not empty. "\

513

676

"%(action)s."

514

677

678

# FIXME: It's a bit strange that the default action is not coherent with

679

# MissingParent from the *user* pov.

680

681

def action_take_this(self, tree):

682

# just acccept bzr proposal

683

pass

684

685

def action_take_other(self, tree):

686

tree.remove([self.path], force=True, keep_files=False)

687

515

688

516

689

class NonDirectoryParent(HandledConflict):

517

"""An attempt to add files to a directory that is not a director or

690

"""An attempt to add files to a directory that is not a directory or

518

691

an attempt to change the kind of a directory with files.

519

692

"""

520

693

523

696

format = "Conflict: %(path)s is not a directory, but has files in it."\

524

697

" %(action)s."

525

698

699

# FIXME: .OTHER should be used instead of .new when the conflict is created

700

701

def action_take_this(self, tree):

702

# FIXME: we should preserve that path when the conflict is generated !

703

if self.path.endswith('.new'):

704

conflict_path = self.path[:-(len('.new'))]

705

tree.remove([self.path], force=True, keep_files=False)

706

tree.add(conflict_path)

707

else:

708

raise NotImplementedError(self.action_take_this)

709

710

def action_take_other(self, tree):

711

# FIXME: we should preserve that path when the conflict is generated !

712

if self.path.endswith('.new'):

713

conflict_path = self.path[:-(len('.new'))]

714

tree.remove([conflict_path], force=True, keep_files=False)

715

tree.rename_one(self.path, conflict_path)

716

else:

717

raise NotImplementedError(self.action_take_other)

718

719

526

720

ctype = {}

527

721

528

722

532

726

for conflict_type in conflict_types:

533

727

ctype[conflict_type.typestring] = conflict_type

534

728

535

536

729

register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,

537

730

DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,

538

731

DeletingParent, NonDirectoryParent)