← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin Pool
  • Date: 2005-06-27 01:26:11 UTC
  • Revision ID: mbp@sourcefrog.net-20050627012611-4effb7007553fde1
- tweak rsync upload script

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
 
1
from merge_core import merge_flex
2
2
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory, Diff3Merge
 
3
from changeset import Inventory
4
4
from bzrlib import find_branch
5
5
import bzrlib.osutils
6
6
from bzrlib.errors import BzrCommandError
80
80
        moved_path = self.add_suffix(target, ".moved")
81
81
        self.conflict("Moved existing %s to %s" % (target, moved_path))
82
82
 
83
 
    def rmdir_non_empty(self, filename):
84
 
        """Handle the case where the dir to be removed still has contents"""
85
 
        self.conflict("Directory %s not removed because it is not empty"\
86
 
            % filename)
87
 
        return "skip"
88
 
 
89
83
    def finalize(self):
90
84
        if not self.ignore_zero:
91
85
            print "%d conflicts encountered.\n" % self.conflicts
127
121
def inventory_map(tree):
128
122
    inventory = {}
129
123
    for file_id in tree.inventory:
 
124
        if not file_exists(tree, file_id):
 
125
            continue
130
126
        path = abspath(tree, file_id)
131
127
        inventory[path] = SourceFile(path, file_id)
132
128
    return inventory
145
141
        os.mkdir(os.path.join(self.tempdir, "texts"))
146
142
        self.cached = {}
147
143
 
148
 
    def __contains__(self, file_id):
149
 
        return file_id in self.tree
150
 
 
151
 
    def get_file_sha1(self, id):
152
 
        return self.tree.get_file_sha1(id)
153
 
 
154
144
    def readonly_path(self, id):
155
 
        if id not in self.tree:
156
 
            return None
157
145
        if self.root is not None:
158
146
            return self.tree.abspath(self.tree.id2path(id))
159
147
        else:
171
159
 
172
160
def merge(other_revision, base_revision,
173
161
          check_clean=True, ignore_zero=False,
174
 
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
175
 
          file_list=None):
 
162
          this_dir=None):
176
163
    """Merge changes into a tree.
177
164
 
178
165
    base_revision
207
194
                raise UnrelatedBranches()
208
195
            base_revision = ['.', base_revno]
209
196
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
210
 
        if file_list is None:
211
 
            interesting_ids = None
212
 
        else:
213
 
            interesting_ids = set()
214
 
            this_tree = this_branch.working_tree()
215
 
            for fname in file_list:
216
 
                path = this_branch.relpath(fname)
217
 
                found_id = False
218
 
                for tree in (this_tree, base_tree.tree, other_tree.tree):
219
 
                    file_id = tree.inventory.path2id(path)
220
 
                    if file_id is not None:
221
 
                        interesting_ids.add(file_id)
222
 
                        found_id = True
223
 
                if not found_id:
224
 
                    raise BzrCommandError("%s is not a source file in any"
225
 
                                          " tree." % fname)
226
197
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
227
 
                    ignore_zero=ignore_zero, backup_files=backup_files, 
228
 
                    merge_type=merge_type, interesting_ids=interesting_ids)
 
198
                    ignore_zero=ignore_zero)
229
199
    finally:
230
200
        shutil.rmtree(tempdir)
231
201
 
232
202
 
233
 
def set_interesting(inventory_a, inventory_b, interesting_ids):
234
 
    """Mark files whose ids are in interesting_ids as interesting
235
 
    """
236
 
    for inventory in (inventory_a, inventory_b):
237
 
        for path, source_file in inventory.iteritems():
238
 
             source_file.interesting = source_file.id in interesting_ids
239
 
 
240
 
 
241
 
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
242
 
                            interesting_ids=None):
243
 
    """Generate a changeset.  If interesting_ids is supplied, only changes
244
 
    to those files will be shown.  Metadata changes are stripped.
 
203
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b):
 
204
    """Generate a changeset, using the text_id to mark really-changed files.
 
205
    This permits blazing comparisons when text_ids are present.  It also
 
206
    disables metadata comparison for files with identical texts.
245
207
    """ 
246
 
    if interesting_ids is not None:
247
 
        set_interesting(inventory_a, inventory_b, interesting_ids)
 
208
    for file_id in tree_a.tree.inventory:
 
209
        if file_id not in tree_b.tree.inventory:
 
210
            continue
 
211
        entry_a = tree_a.tree.inventory[file_id]
 
212
        entry_b = tree_b.tree.inventory[file_id]
 
213
        if (entry_a.kind, entry_b.kind) != ("file", "file"):
 
214
            continue
 
215
        if None in (entry_a.text_id, entry_b.text_id):
 
216
            continue
 
217
        if entry_a.text_id != entry_b.text_id:
 
218
            continue
 
219
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
 
220
        inventory_b[abspath(tree_b.tree, file_id)].interesting = False
248
221
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
249
222
    for entry in cset.entries.itervalues():
250
223
        entry.metadata_change = None
252
225
 
253
226
 
254
227
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
255
 
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
256
 
                interesting_ids=None):
257
 
 
258
 
    def merge_factory(base_file, other_file):
259
 
        contents_change = merge_type(base_file, other_file)
260
 
        if backup_files:
261
 
            contents_change = BackupBeforeChange(contents_change)
262
 
        return contents_change
263
 
    
264
 
    def generate_cset(tree_a, tree_b, inventory_a, inventory_b):
265
 
        return generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
266
 
                                       interesting_ids)
267
 
 
 
228
                ignore_zero=False):
268
229
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
269
230
 
270
231
    def get_inventory(tree):
271
232
        return tree.inventory
272
233
 
273
234
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
274
 
                             generate_cset, get_inventory,
 
235
                             generate_cset_optimized, get_inventory,
275
236
                             MergeConflictHandler(base_tree.root,
276
 
                                                  ignore_zero=ignore_zero),
277
 
                             merge_factory=merge_factory)
 
237
                                                  ignore_zero=ignore_zero))
278
238
 
279
239
    adjust_ids = []
280
240
    for id, path in inv_changes.iteritems():
285
245
                assert path.startswith('./')
286
246
            path = path[2:]
287
247
        adjust_ids.append((path, id))
288
 
    if len(adjust_ids) > 0:
289
 
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
290
 
                                                  adjust_ids))
 
248
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
291
249
 
292
250
 
293
251
def regen_inventory(this_branch, root, new_entries):
330
288
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
331
289
    new_inventory_list.sort()
332
290
    return new_inventory_list
333
 
 
334
 
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
335
 
                     "diff3": (Diff3Merge,  "Merge using external diff3")
336
 
              }
337