129
156
if meta_modified:
132
print >>to_file, ' %s => %s %s' % (oldpath, newpath, fid)
134
print >>to_file, ' %s => %s' % (oldpath, newpath)
159
to_file.write(indent + '%s %s => %s %s\n' % (
160
short_status_letter, oldpath, newpath, fid))
162
to_file.write(indent + '%s %s => %s\n' % (
163
short_status_letter, oldpath, newpath))
165
if self.kind_changed:
167
short_status_letter = 'K'
169
to_file.write(indent + 'kind changed:\n')
170
short_status_letter = ''
171
for (path, fid, old_kind, new_kind) in self.kind_changed:
176
to_file.write(indent + '%s %s (%s => %s)%s\n' % (
177
short_status_letter, path, old_kind, new_kind, suffix))
136
179
if self.modified or extra_modified:
137
print >>to_file, 'modified:'
138
show_list(self.modified)
139
show_list(extra_modified)
180
short_status_letter = 'M'
182
to_file.write(indent + 'modified:\n')
183
short_status_letter = ''
184
show_list(self.modified, short_status_letter)
185
show_list(extra_modified, short_status_letter)
141
187
if show_unchanged and self.unchanged:
142
print >>to_file, 'unchanged:'
143
show_list(self.unchanged)
146
@deprecated_function(zero_nine)
147
def compare_trees(old_tree, new_tree, want_unchanged=False,
148
specific_files=None, extra_trees=None,
149
require_versioned=False):
150
"""compare_trees was deprecated in 0.10. Please see Tree.changes_from."""
151
return new_tree.changes_from(old_tree,
152
want_unchanged=want_unchanged,
153
specific_files=specific_files,
154
extra_trees=extra_trees,
155
require_versioned=require_versioned)
158
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids):
160
from osutils import is_inside_any
162
old_inv = old_tree.inventory
163
new_inv = new_tree.inventory
189
to_file.write(indent + 'unchanged:\n')
190
show_list(self.unchanged)
192
show_list(self.unchanged, 'S')
195
to_file.write(indent + 'unknown:\n')
196
show_list(self.unversioned)
198
def get_changes_as_text(self, show_ids=False, show_unchanged=False,
201
output = StringIO.StringIO()
202
self.show(output, show_ids, show_unchanged, short_status)
203
return output.getvalue()
206
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files,
207
include_root, extra_trees=None,
208
require_versioned=False, want_unversioned=False):
209
"""Worker function that implements Tree.changes_from."""
164
210
delta = TreeDelta()
165
211
# mutter('start compare_trees')
167
# TODO: Rather than iterating over the whole tree and then filtering, we
168
# could diff just the specified files (if any) and their subtrees.
170
old_files = old_tree.list_files()
171
new_files = new_tree.list_files()
182
except StopIteration:
183
return None, None, None, None, None
184
old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
185
new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
188
def check_matching(old_path, old_entry, new_path, new_entry):
189
"""We have matched up 2 file_ids, check for changes."""
190
assert old_entry.kind == new_entry.kind
192
if specific_file_ids:
193
if (old_entry.file_id not in specific_file_ids and
194
new_entry.file_id not in specific_file_ids):
197
# temporary hack until all entries are populated before clients
199
old_entry._read_tree_state(old_path, old_tree)
200
new_entry._read_tree_state(new_path, new_tree)
201
text_modified, meta_modified = new_entry.detect_changes(old_entry)
203
# If the name changes, or the parent_id changes, we have a rename
204
# (if we move a parent, that doesn't count as a rename for the file)
205
if (old_entry.name != new_entry.name
206
or old_entry.parent_id != new_entry.parent_id):
207
delta.renamed.append((old_path,
209
old_entry.file_id, old_entry.kind,
210
text_modified, meta_modified))
211
elif text_modified or meta_modified:
212
delta.modified.append((new_path, new_entry.file_id, new_entry.kind,
213
text_modified, meta_modified))
215
delta.unchanged.append((new_path, new_entry.file_id, new_entry.kind))
218
def handle_old(path, entry):
219
"""old entry without a new entry match
221
Check to see if a matching new entry was already seen as an
222
added file, and switch the pair into being a rename.
223
Otherwise just mark the old entry being removed.
225
if entry.file_id in added:
226
# Actually this is a rename, we found a new file_id earlier
227
# at a different location, so it is no-longer added
228
x_new_path, x_new_entry = added.pop(entry.file_id)
229
check_matching(path, entry, x_new_path, x_new_entry)
231
# We have an old_file_id which doesn't line up with a new_file_id
232
# So this file looks to be removed
233
assert entry.file_id not in removed
234
removed[entry.file_id] = path, entry
236
def handle_new(path, entry):
237
"""new entry without an old entry match
239
Check to see if a matching old entry was already seen as a
240
removal, and change the pair into a rename.
241
Otherwise just mark the new entry as an added file.
243
if entry.file_id in removed:
244
# We saw this file_id earlier at an old different location
245
# it is no longer removed, just renamed
246
x_old_path, x_old_entry = removed.pop(entry.file_id)
247
check_matching(x_old_path, x_old_entry, path, entry)
249
# We have a new file which does not match an old file
251
assert entry.file_id not in added
252
added[entry.file_id] = path, entry
254
while old_path or new_path:
255
# list_files() returns files in alphabetical path sorted order
256
if old_path == new_path:
257
if old_file_id == new_file_id:
258
# This is the common case, the files are in the same place
259
# check if there were any content changes
261
if old_file_id is None:
262
# We have 2 unversioned files, no deltas possible???
265
check_matching(old_path, old_entry, new_path, new_entry)
213
for (file_id, path, content_change, versioned, parent_id, name, kind,
214
executable) in new_tree._iter_changes(old_tree, want_unchanged,
215
specific_files, extra_trees=extra_trees,
216
require_versioned=require_versioned,
217
want_unversioned=want_unversioned):
218
if versioned == (False, False):
219
delta.unversioned.append((path[1], None, kind[1]))
221
if not include_root and (None, None) == parent_id:
223
fully_present = tuple((versioned[x] and kind[x] is not None) for
225
if fully_present[0] != fully_present[1]:
226
if fully_present[1] is True:
227
delta.added.append((path[1], file_id, kind[1]))
267
# The ids don't match, so we have to handle them both
269
if old_file_id is not None:
270
handle_old(old_path, old_entry)
272
if new_file_id is not None:
273
handle_new(new_path, new_entry)
275
# The two entries were at the same path, so increment both sides
276
old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
277
new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
278
elif new_path is None or (old_path is not None and old_path < new_path):
279
# Assume we don't match, only process old_path
280
if old_file_id is not None:
281
handle_old(old_path, old_entry)
282
# old_path came first, so increment it, trying to match up
283
old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
284
elif new_path is not None:
285
# new_path came first, so increment it, trying to match up
286
if new_file_id is not None:
287
handle_new(new_path, new_entry)
288
new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
290
# Now we have a set of added and removed files, mark them all
291
for old_path, old_entry in removed.itervalues():
292
if specific_file_ids:
293
if not old_entry.file_id in specific_file_ids:
295
delta.removed.append((old_path, old_entry.file_id, old_entry.kind))
296
for new_path, new_entry in added.itervalues():
297
if specific_file_ids:
298
if not new_entry.file_id in specific_file_ids:
300
delta.added.append((new_path, new_entry.file_id, new_entry.kind))
229
assert fully_present[0] is True
230
delta.removed.append((path[0], file_id, kind[0]))
231
elif fully_present[0] is False:
233
elif name[0] != name[1] or parent_id[0] != parent_id[1]:
234
# If the name changes, or the parent_id changes, we have a rename
235
# (if we move a parent, that doesn't count as a rename for the
237
delta.renamed.append((path[0],
242
(executable[0] != executable[1])))
243
elif kind[0] != kind[1]:
244
delta.kind_changed.append((path[1], file_id, kind[0], kind[1]))
245
elif content_change is True or executable[0] != executable[1]:
246
delta.modified.append((path[1], file_id, kind[1],
248
(executable[0] != executable[1])))
250
delta.unchanged.append((path[1], file_id, kind[1]))
302
252
delta.removed.sort()
303
253
delta.added.sort()
308
258
delta.unchanged.sort()
263
class _ChangeReporter(object):
264
"""Report changes between two trees"""
266
def __init__(self, output=None, suppress_root_add=True,
267
output_file=None, unversioned_filter=None):
270
:param output: a function with the signature of trace.note, i.e.
271
accepts a format and parameters.
272
:param supress_root_add: If true, adding the root will be ignored
273
(i.e. when a tree has just been initted)
274
:param output_file: If supplied, a file-like object to write to.
275
Only one of output and output_file may be supplied.
276
:param unversioned_filter: A filter function to be called on
277
unversioned files. This should return True to ignore a path.
278
By default, no filtering takes place.
280
if output_file is not None:
281
if output is not None:
282
raise BzrError('Cannot specify both output and output_file')
283
def output(fmt, *args):
284
output_file.write((fmt % args) + '\n')
286
if self.output is None:
287
from bzrlib import trace
288
self.output = trace.note
289
self.suppress_root_add = suppress_root_add
290
self.modified_map = {'kind changed': 'K',
295
self.versioned_map = {'added': '+', # versioned target
296
'unchanged': ' ', # versioned in both
297
'removed': '-', # versioned in source
298
'unversioned': '?', # versioned in neither
300
self.unversioned_filter = unversioned_filter
302
def report(self, file_id, paths, versioned, renamed, modified, exe_change,
304
"""Report one change to a file
306
:param file_id: The file_id of the file
307
:param path: The old and new paths as generated by Tree._iter_changes.
308
:param versioned: may be 'added', 'removed', 'unchanged', or
310
:param renamed: may be True or False
311
:param modified: may be 'created', 'deleted', 'kind changed',
312
'modified' or 'unchanged'.
313
:param exe_change: True if the execute bit has changed
314
:param kind: A pair of file kinds, as generated by Tree._iter_changes.
315
None indicates no file present.
317
if paths[1] == '' and versioned == 'added' and self.suppress_root_add:
319
if versioned == 'unversioned':
320
# skip ignored unversioned files if needed.
321
if self.unversioned_filter is not None:
322
if self.unversioned_filter(paths[1]):
324
# dont show a content change in the output.
325
modified = 'unchanged'
326
# we show both paths in the following situations:
327
# the file versioning is unchanged AND
328
# ( the path is different OR
329
# the kind is different)
330
if (versioned == 'unchanged' and
331
(renamed or modified == 'kind changed')):
333
# on a rename, we show old and new
334
old_path, path = paths
336
# if it's not renamed, we're showing both for kind changes
337
# so only show the new path
338
old_path, path = paths[1], paths[1]
339
# if the file is not missing in the source, we show its kind
340
# when we show two paths.
341
if kind[0] is not None:
342
old_path += osutils.kind_marker(kind[0])
344
elif versioned == 'removed':
345
# not present in target
354
rename = self.versioned_map[versioned]
355
# we show the old kind on the new path when the content is deleted.
356
if modified == 'deleted':
357
path += osutils.kind_marker(kind[0])
358
# otherwise we always show the current kind when there is one
359
elif kind[1] is not None:
360
path += osutils.kind_marker(kind[1])
365
self.output("%s%s%s %s%s", rename, self.modified_map[modified], exe,
369
def report_changes(change_iterator, reporter):
370
"""Report the changes from a change iterator.
372
This is essentially a translation from low-level to medium-level changes.
373
Further processing may be required to produce a human-readable output.
374
Unfortunately, some tree-changing operations are very complex
375
:change_iterator: an iterator or sequence of changes in the format
376
generated by Tree._iter_changes
377
:param reporter: The _ChangeReporter that will report the changes.
379
versioned_change_map = {
380
(True, True) : 'unchanged',
381
(True, False) : 'removed',
382
(False, True) : 'added',
383
(False, False): 'unversioned',
385
for (file_id, path, content_change, versioned, parent_id, name, kind,
386
executable) in change_iterator:
388
# files are "renamed" if they are moved or if name changes, as long
390
if None not in name and None not in parent_id and\
391
(name[0] != name[1] or parent_id[0] != parent_id[1]):
395
if kind[0] != kind[1]:
398
elif kind[1] is None:
401
modified = "kind changed"
404
modified = "modified"
406
modified = "unchanged"
407
if kind[1] == "file":
408
exe_change = (executable[0] != executable[1])
409
versioned_change = versioned_change_map[versioned]
410
reporter.report(file_id, path, versioned_change, renamed, modified,
added
removed
bzrlib/delta.py
