~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

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

• reverse the comparison (5425.4.3 to 5425.5.4)
• stop comparing with revision 5425.5.4

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

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

514

504

        # Adjust the path for the retained file id

515

505

        tid = tt.trans_id_file_id(file_id)

516

506

        parent_tid = tt.get_tree_parent(tid)

517

 

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

 

507

        tt.adjust_path(path, parent_tid, tid)

518

508

        tt.apply()

519

509

 

520

510

    def _revision_tree(self, tree, revid):

600

590

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

601

591

        this_tid = tt.trans_id_file_id(self.file_id)

602

592

        parent_tid = tt.get_tree_parent(this_tid)

603

 

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

 

593

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

604

594

        tt.apply()

605

595

 

606

596

    def action_take_this(self, tree):

610

600

        self._resolve_with_cleanups(tree, 'THIS')

611

601

 

612

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

 

613

606

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

614

607

# how the conflicts were generated.

615

 

class TextConflict(Conflict):

 

608

class TextConflict(PathConflict):

616

609

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

617

610

 

618

611

    has_files = True

621

614

 

622

615

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

623

616

 

624

 

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

625

 

 

626

617

    def associated_filenames(self):

627

618

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

628

619

 

629

 

    def _resolve(self, tt, winner_suffix):

630

 

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

631

 

 

632

 

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

633

 

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

634

 

 

635

 

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

636

 

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

637

 

        ignoring every difference that could have been merged cleanly.

638

 

        """

639

 

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

640

 

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

641

 

        item_tid = tt.trans_id_file_id(self.file_id)

642

 

        item_parent_tid = tt.get_tree_parent(item_tid)

643

 

        winner_path = self.path + '.' + winner_suffix

644

 

        winner_tid = tt.trans_id_tree_path(winner_path)

645

 

        winner_parent_tid = tt.get_tree_parent(winner_tid)

646

 

        # Switch the paths to preserve the content

647

 

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

648

 

                       winner_parent_tid, winner_tid)

649

 

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

650

 

        # Associate the file_id to the right content

651

 

        tt.unversion_file(item_tid)

652

 

        tt.version_file(self.file_id, winner_tid)

653

 

        tt.apply()

654

 

 

655

 

    def action_take_this(self, tree):

656

 

        self._resolve_with_cleanups(tree, 'THIS')

657

 

 

658

 

    def action_take_other(self, tree):

659

 

        self._resolve_with_cleanups(tree, 'OTHER')

660

 

 

661

620

 

662

621

class HandledConflict(Conflict):

663

622

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

756

715

        pass

757

716

 

758

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)

759

722

        tt = transform.TreeTransform(tree)

760

723

        try:

761

724

            p_tid = tt.trans_id_file_id(self.file_id)

762

725

            parent_tid = tt.get_tree_parent(p_tid)

763

726

            cp_tid = tt.trans_id_file_id(self.conflict_file_id)

764

727

            cparent_tid = tt.get_tree_parent(cp_tid)

765

 

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

766

 

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

767

 

                           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)

768

730

            tt.apply()

769

731

        finally:

770

732

            tt.finalize()

• Older »

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