~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

• browse files at revision 5462.5.3
• compare with another revision
• download diff
• download tarball
• view history from revision 5462.5.3

• reverse the comparison (5462.5.3 to 6005)
• stop comparing with revision 6005

Show diffs side-by-side

added

removed

bzrlib/conflicts.py

1

 

# Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011 Canonical Ltd

 

1

# Copyright (C) 2005, 2006, 2007, 2009, 2010 Canonical Ltd

2

2

#

3

3

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

4

4

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

25

25

 

26

26

from bzrlib import (

27

27

    cleanup,

 

28

    commands,

28

29

    errors,

29

30

    osutils,

30

31

    rio,

34

35

    )

35

36

""")

36

37

from bzrlib import (

37

 

    commands,

38

38

    option,

39

39

    registry,

40

40

    )

72

72

                    continue

73

73

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

74

74

            else:

75

 

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

 

75

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

76

76

 

77

77

 

78

78

resolve_action_registry = registry.Registry()

117

117

            ResolveActionOption(),

118

118

            ]

119

119

    _see_also = ['conflicts']

120

 

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

 

120

    def run(self, file_list=None, all=False, action=None, directory=u'.'):

121

121

        if all:

122

122

            if file_list:

123

123

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

124

124

                                             " no FILE may be provided")

125

 

            if directory is None:

126

 

                directory = u'.'

127

125

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

128

126

            if action is None:

129

127

                action = 'done'

130

128

        else:

131

129

            tree, file_list = workingtree.WorkingTree.open_containing_paths(

132

 

                file_list, directory)

 

130

                file_list)

133

131

            if file_list is None:

134

132

                if action is None:

135

133

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

148

146

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

149

147

                    trace.note('Remaining conflicts:')

150

148

                    for conflict in un_resolved:

151

 

                        trace.note(unicode(conflict))

 

149

                        trace.note(conflict)

152

150

                    return 1

153

151

                else:

154

152

                    trace.note('All conflicts resolved.')

159

157

                # conflict.auto(tree) --vila 091242

160

158

                pass

161

159

        else:

162

 

            before, after = resolve(tree, file_list, action=action)

163

 

            trace.note('%d conflict(s) resolved, %d remaining'

164

 

                       % (before - after, after))

 

160

            resolve(tree, file_list, action=action)

165

161

 

166

162

 

167

163

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

180

176

    :param action: How the conflict should be resolved,

181

177

    """

182

178

    tree.lock_tree_write()

183

 

    nb_conflicts_after = None

184

179

    try:

185

180

        tree_conflicts = tree.conflicts()

186

 

        nb_conflicts_before = len(tree_conflicts)

187

181

        if paths is None:

188

182

            new_conflicts = ConflictList()

189

183

            to_process = tree_conflicts

197

191

            except NotImplementedError:

198

192

                new_conflicts.append(conflict)

199

193

        try:

200

 

            nb_conflicts_after = len(new_conflicts)

201

194

            tree.set_conflicts(new_conflicts)

202

195

        except errors.UnsupportedOperation:

203

196

            pass

204

197

    finally:

205

198

        tree.unlock()

206

 

    if nb_conflicts_after is None:

207

 

        nb_conflicts_after = nb_conflicts_before

208

 

    return nb_conflicts_before, nb_conflicts_after

209

199

 

210

200

 

211

201

def restore(filename):

291

281

    def to_strings(self):

292

282

        """Generate strings for the provided conflicts"""

293

283

        for conflict in self:

294

 

            yield unicode(conflict)

 

284

            yield str(conflict)

295

285

 

296

286

    def remove_files(self, tree):

297

287

        """Remove the THIS, BASE and OTHER files for listed conflicts"""

390

380

    def __ne__(self, other):

391

381

        return not self.__eq__(other)

392

382

 

393

 

    def __unicode__(self):

 

383

    def __str__(self):

394

384

        return self.format % self.__dict__

395

385

 

396

386

    def __repr__(self):

507

497

        if path_to_create is not None:

508

498

            tid = tt.trans_id_tree_path(path_to_create)

509

499

            transform.create_from_tree(

510

 

                tt, tid, self._revision_tree(tt._tree, revid), file_id)

 

500

                tt, tt.trans_id_tree_path(path_to_create),

 

501

                self._revision_tree(tt._tree, revid), file_id)

511

502

            tt.version_file(file_id, tid)

512

 

        else:

513

 

            tid = tt.trans_id_file_id(file_id)

 

503

 

514

504

        # Adjust the path for the retained file id

 

505

        tid = tt.trans_id_file_id(file_id)

515

506

        parent_tid = tt.get_tree_parent(tid)

516

 

        tt.adjust_path(osutils.basename(path), parent_tid, tid)

 

507

        tt.adjust_path(path, parent_tid, tid)

517

508

        tt.apply()

518

509

 

519

510

    def _revision_tree(self, tree, revid):

582

573

        :param tt: The TreeTransform where the conflict is resolved.

583

574

        :param suffix_to_remove: Either 'THIS' or 'OTHER'

584

575

 

585

 

        The resolution is symmetric: when taking THIS, OTHER is deleted and

 

576

        The resolution is symmetric, when taking THIS, OTHER is deleted and

586

577

        item.THIS is renamed into item and vice-versa.

587

578

        """

588

579

        try:

595

586

            # never existed or was already deleted (including the case

596

587

            # where the user deleted it)

597

588

            pass

598

 

        try:

599

 

            this_path = tt._tree.id2path(self.file_id)

600

 

        except errors.NoSuchId:

601

 

            # The file is not present anymore. This may happen if the user

602

 

            # deleted the file either manually or when resolving a conflict on

603

 

            # the parent.  We may raise some exception to indicate that the

604

 

            # conflict doesn't exist anymore and as such doesn't need to be

605

 

            # resolved ? -- vila 20110615 

606

 

            this_tid = None

607

 

        else:

608

 

            this_tid = tt.trans_id_tree_path(this_path)

609

 

        if this_tid is not None:

610

 

            # Rename 'item.suffix_to_remove' (note that if

611

 

            # 'item.suffix_to_remove' has been deleted, this is a no-op)

612

 

            parent_tid = tt.get_tree_parent(this_tid)

613

 

            tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)

614

 

            tt.apply()

 

589

        # Rename 'item.suffix_to_remove' (note that if

 

590

        # 'item.suffix_to_remove' has been deleted, this is a no-op)

 

591

        this_tid = tt.trans_id_file_id(self.file_id)

 

592

        parent_tid = tt.get_tree_parent(this_tid)

 

593

        tt.adjust_path(self.path, parent_tid, this_tid)

 

594

        tt.apply()

615

595

 

616

596

    def action_take_this(self, tree):

617

597

        self._resolve_with_cleanups(tree, 'OTHER')

620

600

        self._resolve_with_cleanups(tree, 'THIS')

621

601

 

622

602

 

 

603

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

 

604

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

 

605

 

623

606

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

624

607

# how the conflicts were generated.

625

 

class TextConflict(Conflict):

 

608

class TextConflict(PathConflict):

626

609

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

627

610

 

628

611

    has_files = True

631

614

 

632

615

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

633

616

 

634

 

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

635

 

 

636

617

    def associated_filenames(self):

637

618

        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]

638

619

 

639

 

    def _resolve(self, tt, winner_suffix):

640

 

        """Resolve the conflict by copying one of .THIS or .OTHER into file.

641

 

 

642

 

        :param tt: The TreeTransform where the conflict is resolved.

643

 

        :param winner_suffix: Either 'THIS' or 'OTHER'

644

 

 

645

 

        The resolution is symmetric, when taking THIS, item.THIS is renamed

646

 

        into item and vice-versa. This takes one of the files as a whole

647

 

        ignoring every difference that could have been merged cleanly.

648

 

        """

649

 

        # To avoid useless copies, we switch item and item.winner_suffix, only

650

 

        # item will exist after the conflict has been resolved anyway.

651

 

        item_tid = tt.trans_id_file_id(self.file_id)

652

 

        item_parent_tid = tt.get_tree_parent(item_tid)

653

 

        winner_path = self.path + '.' + winner_suffix

654

 

        winner_tid = tt.trans_id_tree_path(winner_path)

655

 

        winner_parent_tid = tt.get_tree_parent(winner_tid)

656

 

        # Switch the paths to preserve the content

657

 

        tt.adjust_path(osutils.basename(self.path),

658

 

                       winner_parent_tid, winner_tid)

659

 

        tt.adjust_path(osutils.basename(winner_path), item_parent_tid, item_tid)

660

 

        # Associate the file_id to the right content

661

 

        tt.unversion_file(item_tid)

662

 

        tt.version_file(self.file_id, winner_tid)

663

 

        tt.apply()

664

 

 

665

 

    def action_take_this(self, tree):

666

 

        self._resolve_with_cleanups(tree, 'THIS')

667

 

 

668

 

    def action_take_other(self, tree):

669

 

        self._resolve_with_cleanups(tree, 'OTHER')

670

 

 

671

620

 

672

621

class HandledConflict(Conflict):

673

622

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

766

715

        pass

767

716

 

768

717

    def action_take_other(self, tree):

 

718

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

 

719

        # is probably a bug or two...)

 

720

        base_path = osutils.basename(self.path)

 

721

        conflict_base_path = osutils.basename(self.conflict_path)

769

722

        tt = transform.TreeTransform(tree)

770

723

        try:

771

724

            p_tid = tt.trans_id_file_id(self.file_id)

772

725

            parent_tid = tt.get_tree_parent(p_tid)

773

726

            cp_tid = tt.trans_id_file_id(self.conflict_file_id)

774

727

            cparent_tid = tt.get_tree_parent(cp_tid)

775

 

            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)

776

 

            tt.adjust_path(osutils.basename(self.conflict_path),

777

 

                           parent_tid, p_tid)

 

728

            tt.adjust_path(base_path, cparent_tid, cp_tid)

 

729

            tt.adjust_path(conflict_base_path, parent_tid, p_tid)

778

730

            tt.apply()

779

731

        finally:

780

732

            tt.finalize()

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1