13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
23
from bzrlib.lazy_import import lazy_import
30
29
from bzrlib import (
31
branch as _mod_branch,
41
from bzrlib.workingtree import WorkingTree
42
from bzrlib.symbol_versioning import (
46
from bzrlib.trace import warning
44
from bzrlib.registry import (
47
from bzrlib.trace import mutter, note, warning
50
class AtTemplate(string.Template):
51
"""Templating class that uses @ instead of $."""
49
56
# TODO: Rather than building a changeset object, we should probably
86
93
if sequence_matcher is None:
87
94
sequence_matcher = patiencediff.PatienceSequenceMatcher
88
95
ud = patiencediff.unified_diff(oldlines, newlines,
89
fromfile=old_filename.encode(path_encoding),
90
tofile=new_filename.encode(path_encoding),
96
fromfile=old_filename.encode(path_encoding, 'replace'),
97
tofile=new_filename.encode(path_encoding, 'replace'),
91
98
sequencematcher=sequence_matcher)
278
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
287
def get_trees_and_branches_to_diff_locked(
288
path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
279
289
"""Get the trees and specific files to diff given a list of paths.
281
291
This method works out the trees to be diff'ed and the files of
293
303
The url of the new branch or tree. If None, the tree to use is
294
304
taken from the first path, if any, or the current working tree.
306
a callable like Command.add_cleanup. get_trees_and_branches_to_diff
307
will register cleanups that must be run to unlock the trees, etc.
309
if True and a view is set, apply the view or check that the paths
296
a tuple of (old_tree, new_tree, specific_files, extra_trees) where
297
extra_trees is a sequence of additional trees to search in for
312
a tuple of (old_tree, new_tree, old_branch, new_branch,
313
specific_files, extra_trees) where extra_trees is a sequence of
314
additional trees to search in for file-ids. The trees and branches
315
will be read-locked until the cleanups registered via the add_cleanup
300
318
# Get the old and new revision specs
301
319
old_revision_spec = None
324
342
default_location = path_list[0]
325
343
other_paths = path_list[1:]
345
def lock_tree_or_branch(wt, br):
348
add_cleanup(wt.unlock)
351
add_cleanup(br.unlock)
327
353
# Get the old location
328
354
specific_files = []
329
355
if old_url is None:
330
356
old_url = default_location
331
357
working_tree, branch, relpath = \
332
358
bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
359
lock_tree_or_branch(working_tree, branch)
333
360
if consider_relpath and relpath != '':
361
if working_tree is not None and apply_view:
362
views.check_path_in_view(working_tree, relpath)
334
363
specific_files.append(relpath)
335
364
old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
337
367
# Get the new location
338
368
if new_url is None:
340
370
if new_url != old_url:
341
371
working_tree, branch, relpath = \
342
372
bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
373
lock_tree_or_branch(working_tree, branch)
343
374
if consider_relpath and relpath != '':
375
if working_tree is not None and apply_view:
376
views.check_path_in_view(working_tree, relpath)
344
377
specific_files.append(relpath)
345
378
new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
346
379
basis_is_default=working_tree is None)
348
382
# Get the specific files (all files is None, no files is [])
349
383
if make_paths_wt_relative and working_tree is not None:
350
other_paths = _relative_paths_in_tree(working_tree, other_paths)
384
other_paths = working_tree.safe_relpath_files(
386
apply_view=apply_view)
351
387
specific_files.extend(other_paths)
352
388
if len(specific_files) == 0:
353
389
specific_files = None
390
if (working_tree is not None and working_tree.supports_views()
392
view_files = working_tree.views.lookup_view()
394
specific_files = view_files
395
view_str = views.view_display_str(view_files)
396
note("*** Ignoring files outside view. View is %s" % view_str)
355
398
# Get extra trees that ought to be searched for file-ids
356
399
extra_trees = None
357
400
if working_tree is not None and working_tree not in (old_tree, new_tree):
358
401
extra_trees = (working_tree,)
359
return old_tree, new_tree, specific_files, extra_trees
402
return (old_tree, new_tree, old_branch, new_branch,
403
specific_files, extra_trees)
362
406
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
373
417
return spec.as_tree(branch)
376
def _relative_paths_in_tree(tree, paths):
377
"""Get the relative paths within a working tree.
379
Each path may be either an absolute path or a path relative to the
380
current working directory.
383
for filename in paths:
385
result.append(tree.relpath(osutils.dereference_path(filename)))
386
except errors.PathNotChild:
387
raise errors.BzrCommandError("Files are in different branches")
391
420
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
392
421
external_diff_options=None,
393
422
old_label='a/', new_label='b/',
394
423
extra_trees=None,
395
424
path_encoding='utf8',
397
427
"""Show in text form the changes from one tree to another.
403
Include only changes to these files - None for all changes.
405
external_diff_options
406
If set, use an external GNU diff and pass these options.
409
If set, more Trees to use for looking up file ids
412
If set, the path will be encoded as specified, otherwise is supposed
429
:param to_file: The output stream.
430
:param specific_files: Include only changes to these files - None for all
432
:param external_diff_options: If set, use an external GNU diff and pass
434
:param extra_trees: If set, more Trees to use for looking up file ids
435
:param path_encoding: If set, the path will be encoded as specified,
436
otherwise is supposed to be utf8
437
:param format_cls: Formatter class (DiffTree subclass)
439
if format_cls is None:
440
format_cls = DiffTree
415
441
old_tree.lock_read()
417
443
if extra_trees is not None:
420
446
new_tree.lock_read()
422
differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
424
external_diff_options,
425
old_label, new_label, using)
448
differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
450
external_diff_options,
451
old_label, new_label, using)
426
452
return differ.show_diff(specific_files, extra_trees)
428
454
new_tree.unlock()
436
462
def _patch_header_date(tree, file_id, path):
437
463
"""Returns a timestamp suitable for use in a patch header."""
438
mtime = tree.get_file_mtime(file_id, path)
465
mtime = tree.get_file_mtime(file_id, path)
466
except errors.FileTimestampUnavailable:
439
468
return timestamp.format_patch_date(mtime)
442
@deprecated_function(one_three)
443
def get_prop_change(meta_modified):
445
return " (properties changed)"
449
471
def get_executable_change(old_is_x, new_is_x):
450
472
descr = { True:"+x", False:"-x", None:"??" }
451
473
if old_is_x != new_is_x:
626
648
return self.CANNOT_DIFF
627
649
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
628
650
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
629
return self.diff_text(from_file_id, to_file_id, from_label, to_label)
651
return self.diff_text(from_file_id, to_file_id, from_label, to_label,
631
def diff_text(self, from_file_id, to_file_id, from_label, to_label):
654
def diff_text(self, from_file_id, to_file_id, from_label, to_label,
655
from_path=None, to_path=None):
632
656
"""Diff the content of given files in two trees
634
658
:param from_file_id: The id of the file in the from tree. If None,
636
660
:param to_file_id: The id of the file in the to tree. This may refer
637
661
to a different file from from_file_id. If None,
638
662
the file is not present in the to tree.
663
:param from_path: The path in the from tree or None if unknown.
664
:param to_path: The path in the to tree or None if unknown.
640
def _get_text(tree, file_id):
666
def _get_text(tree, file_id, path):
641
667
if file_id is not None:
642
return tree.get_file(file_id).readlines()
668
return tree.get_file_lines(file_id, path)
646
from_text = _get_text(self.old_tree, from_file_id)
647
to_text = _get_text(self.new_tree, to_file_id)
672
from_text = _get_text(self.old_tree, from_file_id, from_path)
673
to_text = _get_text(self.new_tree, to_file_id, to_path)
648
674
self.text_differ(from_label, from_text, to_label, to_text,
675
self.to_file, path_encoding=self.path_encoding)
650
676
except errors.BinaryFile:
651
677
self.to_file.write(
652
678
("Binary files %s and %s differ\n" %
653
(from_label, to_label)).encode(self.path_encoding))
679
(from_label, to_label)).encode(self.path_encoding,'replace'))
654
680
return self.CHANGED
666
692
def from_string(klass, command_string, old_tree, new_tree, to_file,
667
693
path_encoding='utf-8'):
668
command_template = commands.shlex_split_unicode(command_string)
669
command_template.extend(['%(old_path)s', '%(new_path)s'])
694
command_template = cmdline.split(command_string)
695
if '@' not in command_string:
696
command_template.extend(['@old_path', '@new_path'])
670
697
return klass(command_template, old_tree, new_tree, to_file,
674
def make_from_diff_tree(klass, command_string):
701
def make_from_diff_tree(klass, command_string, external_diff_options=None):
675
702
def from_diff_tree(diff_tree):
676
return klass.from_string(command_string, diff_tree.old_tree,
703
full_command_string = [command_string]
704
if external_diff_options is not None:
705
full_command_string += ' ' + external_diff_options
706
return klass.from_string(full_command_string, diff_tree.old_tree,
677
707
diff_tree.new_tree, diff_tree.to_file)
678
708
return from_diff_tree
680
710
def _get_command(self, old_path, new_path):
681
711
my_map = {'old_path': old_path, 'new_path': new_path}
682
return [t % my_map for t in self.command_template]
712
command = [AtTemplate(t).substitute(my_map) for t in
713
self.command_template]
714
if sys.platform == 'win32': # Popen doesn't accept unicode on win32
717
if isinstance(c, unicode):
718
command_encoded.append(c.encode('mbcs'))
720
command_encoded.append(c)
721
return command_encoded
684
725
def _execute(self, old_path, new_path):
685
726
command = self._get_command(old_path, new_path)
708
def _write_file(self, file_id, tree, prefix, relpath):
709
full_path = osutils.pathjoin(self._root, prefix, relpath)
710
if self._try_symlink_root(tree, prefix):
751
"""Returns safe encoding for passing file path to diff tool"""
752
if sys.platform == 'win32':
755
# Don't fallback to 'utf-8' because subprocess may not be able to
756
# handle utf-8 correctly when locale is not utf-8.
757
return sys.getfilesystemencoding() or 'ascii'
759
def _is_safepath(self, path):
760
"""Return true if `path` may be able to pass to subprocess."""
763
return path == path.encode(fenc).decode(fenc)
767
def _safe_filename(self, prefix, relpath):
768
"""Replace unsafe character in `relpath` then join `self._root`,
769
`prefix` and `relpath`."""
771
# encoded_str.replace('?', '_') may break multibyte char.
772
# So we should encode, decode, then replace(u'?', u'_')
773
relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
774
relpath_tmp = relpath_tmp.replace(u'?', u'_')
775
return osutils.pathjoin(self._root, prefix, relpath_tmp)
777
def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
779
if not force_temp and isinstance(tree, WorkingTree):
780
full_path = tree.abspath(tree.id2path(file_id))
781
if self._is_safepath(full_path):
784
full_path = self._safe_filename(prefix, relpath)
785
if not force_temp and self._try_symlink_root(tree, prefix):
712
787
parent_dir = osutils.dirname(full_path)
727
osutils.make_readonly(full_path)
728
mtime = tree.get_file_mtime(file_id)
729
os.utime(full_path, (mtime, mtime))
803
mtime = tree.get_file_mtime(file_id)
804
except errors.FileTimestampUnavailable:
807
os.utime(full_path, (mtime, mtime))
809
osutils.make_readonly(full_path)
732
def _prepare_files(self, file_id, old_path, new_path):
812
def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
813
allow_write_new=False):
733
814
old_disk_path = self._write_file(file_id, self.old_tree, 'old',
815
old_path, force_temp)
735
816
new_disk_path = self._write_file(file_id, self.new_tree, 'new',
817
new_path, force_temp,
818
allow_write=allow_write_new)
737
819
return old_disk_path, new_disk_path
739
821
def finish(self):
740
osutils.rmtree(self._root)
823
osutils.rmtree(self._root)
825
if e.errno != errno.ENOENT:
826
mutter("The temporary directory \"%s\" was not "
827
"cleanly removed: %s." % (self._root, e))
742
829
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
743
830
if (old_kind, new_kind) != ('file', 'file'):
744
831
return DiffPath.CANNOT_DIFF
745
self._prepare_files(file_id, old_path, new_path)
746
self._execute(osutils.pathjoin('old', old_path),
747
osutils.pathjoin('new', new_path))
832
(old_disk_path, new_disk_path) = self._prepare_files(
833
file_id, old_path, new_path)
834
self._execute(old_disk_path, new_disk_path)
836
def edit_file(self, file_id):
837
"""Use this tool to edit a file.
839
A temporary copy will be edited, and the new contents will be
842
:param file_id: The id of the file to edit.
843
:return: The new contents of the file.
845
old_path = self.old_tree.id2path(file_id)
846
new_path = self.new_tree.id2path(file_id)
847
old_abs_path, new_abs_path = self._prepare_files(
848
file_id, old_path, new_path,
849
allow_write_new=True,
851
command = self._get_command(old_abs_path, new_abs_path)
852
subprocess.call(command, cwd=self._root)
853
new_file = open(new_abs_path, 'rb')
855
return new_file.read()
750
860
class DiffTree(object):
807
918
:param using: Commandline to use to invoke an external diff tool
809
920
if using is not None:
810
extra_factories = [DiffFromTool.make_from_diff_tree(using)]
921
extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
812
923
extra_factories = []
813
924
if external_diff_options:
814
925
opts = external_diff_options.split()
815
def diff_file(olab, olines, nlab, nlines, to_file):
926
def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
927
""":param path_encoding: not used but required
928
to match the signature of internal_diff.
816
930
external_diff(olab, olines, nlab, nlines, to_file, opts)
818
932
diff_file = internal_diff
909
1023
new_kind = self.new_tree.kind(file_id)
910
1024
except (errors.NoSuchId, errors.NoSuchFile):
1026
self._diff(file_id, old_path, new_path, old_kind, new_kind)
1029
def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
913
1030
result = DiffPath._diff_many(self.differs, file_id, old_path,
914
1031
new_path, old_kind, new_kind)
915
1032
if result is DiffPath.CANNOT_DIFF:
added
removed
bzrlib/diff.py
