129
151
if meta_modified:
132
print >>to_file, ' %s => %s %s' % (oldpath, newpath, fid)
134
print >>to_file, ' %s => %s' % (oldpath, newpath)
154
print >>to_file, '%s %s => %s %s' % (
155
short_status_letter, oldpath, newpath, fid)
157
print >>to_file, '%s %s => %s' % (
158
short_status_letter, oldpath, newpath)
160
if self.kind_changed:
162
short_status_letter = 'K'
164
print >>to_file, 'kind changed:'
165
short_status_letter = ''
166
for (path, fid, old_kind, new_kind) in self.kind_changed:
171
print >>to_file, '%s %s (%s => %s)%s' % (
172
short_status_letter, path, old_kind, new_kind, suffix)
136
174
if self.modified or extra_modified:
137
print >>to_file, 'modified:'
138
show_list(self.modified)
139
show_list(extra_modified)
175
short_status_letter = 'M'
177
print >>to_file, 'modified:'
178
short_status_letter = ''
179
show_list(self.modified, short_status_letter)
180
show_list(extra_modified, short_status_letter)
141
182
if show_unchanged and self.unchanged:
142
print >>to_file, 'unchanged:'
143
show_list(self.unchanged)
184
print >>to_file, 'unchanged:'
185
show_list(self.unchanged)
187
show_list(self.unchanged, 'S')
146
190
@deprecated_function(zero_nine)
152
196
want_unchanged=want_unchanged,
153
197
specific_files=specific_files,
154
198
extra_trees=extra_trees,
155
require_versioned=require_versioned)
199
require_versioned=require_versioned,
158
203
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids,
161
from osutils import is_inside_any
163
old_inv = old_tree.inventory
164
new_inv = new_tree.inventory
165
205
delta = TreeDelta()
166
206
# mutter('start compare_trees')
168
# TODO: Rather than iterating over the whole tree and then filtering, we
169
# could diff just the specified files (if any) and their subtrees.
171
old_files = old_tree.list_files(include_root)
172
new_files = new_tree.list_files(include_root)
183
except StopIteration:
184
return None, None, None, None, None
185
old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
186
new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
189
def check_matching(old_path, old_entry, new_path, new_entry):
190
"""We have matched up 2 file_ids, check for changes."""
191
assert old_entry.kind == new_entry.kind
193
if specific_file_ids:
194
if (old_entry.file_id not in specific_file_ids and
195
new_entry.file_id not in specific_file_ids):
198
# temporary hack until all entries are populated before clients
200
old_entry._read_tree_state(old_path, old_tree)
201
new_entry._read_tree_state(new_path, new_tree)
202
text_modified, meta_modified = new_entry.detect_changes(old_entry)
204
# If the name changes, or the parent_id changes, we have a rename
205
# (if we move a parent, that doesn't count as a rename for the file)
206
if (old_entry.name != new_entry.name
207
or old_entry.parent_id != new_entry.parent_id):
208
for (file_id, path, content_change, versioned, parent_id, name, kind,
209
executable) in new_tree._iter_changes(old_tree, want_unchanged,
211
if not include_root and (None, None) == parent_id:
213
fully_present = tuple((versioned[x] and kind[x] is not None) for
215
if fully_present[0] != fully_present[1]:
216
if fully_present[1] is True:
217
delta.added.append((path, file_id, kind[1]))
219
assert fully_present[0] is True
220
old_path = old_tree.id2path(file_id)
221
delta.removed.append((old_path, file_id, kind[0]))
222
elif fully_present[0] is False:
224
elif name[0] != name[1] or parent_id[0] != parent_id[1]:
225
# If the name changes, or the parent_id changes, we have a rename
226
# (if we move a parent, that doesn't count as a rename for the
228
old_path = old_tree.id2path(file_id)
208
229
delta.renamed.append((old_path,
210
old_entry.file_id, old_entry.kind,
211
text_modified, meta_modified))
212
elif text_modified or meta_modified:
213
delta.modified.append((new_path, new_entry.file_id, new_entry.kind,
214
text_modified, meta_modified))
216
delta.unchanged.append((new_path, new_entry.file_id, new_entry.kind))
219
def handle_old(path, entry):
220
"""old entry without a new entry match
222
Check to see if a matching new entry was already seen as an
223
added file, and switch the pair into being a rename.
224
Otherwise just mark the old entry being removed.
226
if entry.file_id in added:
227
# Actually this is a rename, we found a new file_id earlier
228
# at a different location, so it is no-longer added
229
x_new_path, x_new_entry = added.pop(entry.file_id)
230
check_matching(path, entry, x_new_path, x_new_entry)
232
# We have an old_file_id which doesn't line up with a new_file_id
233
# So this file looks to be removed
234
assert entry.file_id not in removed
235
removed[entry.file_id] = path, entry
237
def handle_new(path, entry):
238
"""new entry without an old entry match
240
Check to see if a matching old entry was already seen as a
241
removal, and change the pair into a rename.
242
Otherwise just mark the new entry as an added file.
244
if entry.file_id in removed:
245
# We saw this file_id earlier at an old different location
246
# it is no longer removed, just renamed
247
x_old_path, x_old_entry = removed.pop(entry.file_id)
248
check_matching(x_old_path, x_old_entry, path, entry)
250
# We have a new file which does not match an old file
252
assert entry.file_id not in added
253
added[entry.file_id] = path, entry
255
while old_path is not None or new_path is not None:
256
# list_files() returns files in alphabetical path sorted order
257
if old_path == new_path:
258
if old_file_id == new_file_id:
259
# This is the common case, the files are in the same place
260
# check if there were any content changes
262
if old_file_id is None:
263
# We have 2 unversioned files, no deltas possible???
266
check_matching(old_path, old_entry, new_path, new_entry)
268
# The ids don't match, so we have to handle them both
270
if old_file_id is not None:
271
handle_old(old_path, old_entry)
273
if new_file_id is not None:
274
handle_new(new_path, new_entry)
276
# The two entries were at the same path, so increment both sides
277
old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
278
new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
279
elif new_path is None or (old_path is not None and old_path < new_path):
280
# Assume we don't match, only process old_path
281
if old_file_id is not None:
282
handle_old(old_path, old_entry)
283
# old_path came first, so increment it, trying to match up
284
old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
285
elif new_path is not None:
286
# new_path came first, so increment it, trying to match up
287
if new_file_id is not None:
288
handle_new(new_path, new_entry)
289
new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
291
# Now we have a set of added and removed files, mark them all
292
for old_path, old_entry in removed.itervalues():
293
if specific_file_ids:
294
if not old_entry.file_id in specific_file_ids:
296
delta.removed.append((old_path, old_entry.file_id, old_entry.kind))
297
for new_path, new_entry in added.itervalues():
298
if specific_file_ids:
299
if not new_entry.file_id in specific_file_ids:
301
delta.added.append((new_path, new_entry.file_id, new_entry.kind))
234
(executable[0] != executable[1])))
235
elif kind[0] != kind[1]:
236
delta.kind_changed.append((path, file_id, kind[0], kind[1]))
237
elif content_change is True or executable[0] != executable[1]:
238
delta.modified.append((path, file_id, kind[1],
240
(executable[0] != executable[1])))
242
delta.unchanged.append((path, file_id, kind[1]))
303
244
delta.removed.sort()
304
245
delta.added.sort()
309
250
delta.unchanged.sort()
255
class ChangeReporter(object):
256
"""Report changes between two trees"""
258
def __init__(self, old_inventory, output=None):
259
self.old_inventory = old_inventory
261
if self.output is None:
262
from bzrlib import trace
263
self.output = trace.note
265
def report(self, file_id, path, versioned, renamed, modified, exe_change,
267
"""Report one change to a file
269
:param file_id: The file_id of the file
270
:param path: The path the file has (or would have) in the tree (as
271
generated by Tree._iter_changes)
272
:param versioned: may be 'added', 'removed', or 'unchanged'
273
:param renamed: may be True or False
274
:param modified: may be 'created', 'deleted', 'kind changed',
275
'modified' or 'unchanged'.
276
:param exe_change: True if the execute bit has changed
277
:param kind: A pair of file kinds, as generated by Tree._iter_changes.
278
None indicates no file present.
280
modified_map = {'kind changed': 'K',
285
versioned_map = {'added': '+',
290
old_path = self.old_inventory.id2path(file_id)
293
rename = versioned_map[versioned]
294
if modified == 'kind changed':
297
if modified == 'deleted':
298
path += osutils.kind_marker(kind[0])
300
path += osutils.kind_marker(kind[1])
302
old_path += "%s => " % osutils.kind_marker(kind[0])
307
self.output("%s%s%s %s%s", rename, modified_map[modified], exe,
311
def report_changes(change_iterator, reporter):
312
"""Report the changes from a change iterator.
314
This is essentially a translation from low-level to medium-level changes.
315
Further processing may be required to produce a human-readable output.
316
Unfortunately, some tree-changing operations are very complex
317
:change_iterator: an iterator or sequence of changes in the format
318
generated by Tree._iter_changes
319
:param reporter: The ChangeReporter that will report the changes.
321
for (file_id, path, content_change, versioned, parent_id, name, kind,
322
executable) in change_iterator:
324
# files are "renamed" if they are moved or if name changes, as long
326
if None not in name and (name[0] != name[1] or
327
parent_id[0] != parent_id[1]):
331
if kind[0] != kind[1]:
334
elif kind[1] is None:
337
modified = "kind changed"
340
modified = "modified"
342
modified = "unchanged"
343
if kind[1] == "file":
344
exe_change = (executable[0] != executable[1])
345
if versioned[0] != versioned[1]:
347
versioned_change = "removed"
349
versioned_change = "added"
351
versioned_change = "unchanged"
352
reporter.report(file_id, path, versioned_change, renamed, modified,
added
removed
bzrlib/delta.py
