1
# Copyright (C) 2009-2018 Jelmer Vernooij <jelmer@jelmer.uk>
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
from __future__ import absolute_import
23
from io import BytesIO
26
from dulwich.index import (
27
index_entry_from_stat,
29
from dulwich.object_store import (
33
from dulwich.objects import (
52
from ...revision import NULL_REVISION
54
from .mapping import (
62
class GitTreeDirectory(_mod_tree.TreeDirectory):
64
__slots__ = ['file_id', 'name', 'parent_id', 'children']
66
def __init__(self, file_id, name, parent_id):
67
self.file_id = file_id
69
self.parent_id = parent_id
82
return self.__class__(
83
self.file_id, self.name, self.parent_id)
86
return "%s(file_id=%r, name=%r, parent_id=%r)" % (
87
self.__class__.__name__, self.file_id, self.name,
90
def __eq__(self, other):
91
return (self.kind == other.kind and
92
self.file_id == other.file_id and
93
self.name == other.name and
94
self.parent_id == other.parent_id)
97
class GitTreeFile(_mod_tree.TreeFile):
99
__slots__ = ['file_id', 'name', 'parent_id', 'text_size', 'text_sha1',
102
def __init__(self, file_id, name, parent_id, text_size=None,
103
text_sha1=None, executable=None):
104
self.file_id = file_id
106
self.parent_id = parent_id
107
self.text_size = text_size
108
self.text_sha1 = text_sha1
109
self.executable = executable
115
def __eq__(self, other):
116
return (self.kind == other.kind and
117
self.file_id == other.file_id and
118
self.name == other.name and
119
self.parent_id == other.parent_id and
120
self.text_sha1 == other.text_sha1 and
121
self.text_size == other.text_size and
122
self.executable == other.executable)
125
return "%s(file_id=%r, name=%r, parent_id=%r, text_size=%r, text_sha1=%r, executable=%r)" % (
126
type(self).__name__, self.file_id, self.name, self.parent_id,
127
self.text_size, self.text_sha1, self.executable)
130
ret = self.__class__(
131
self.file_id, self.name, self.parent_id)
132
ret.text_sha1 = self.text_sha1
133
ret.text_size = self.text_size
134
ret.executable = self.executable
138
class GitTreeSymlink(_mod_tree.TreeLink):
140
__slots__ = ['file_id', 'name', 'parent_id', 'symlink_target']
142
def __init__(self, file_id, name, parent_id,
143
symlink_target=None):
144
self.file_id = file_id
146
self.parent_id = parent_id
147
self.symlink_target = symlink_target
154
def executable(self):
162
return "%s(file_id=%r, name=%r, parent_id=%r, symlink_target=%r)" % (
163
type(self).__name__, self.file_id, self.name, self.parent_id,
166
def __eq__(self, other):
167
return (self.kind == other.kind and
168
self.file_id == other.file_id and
169
self.name == other.name and
170
self.parent_id == other.parent_id and
171
self.symlink_target == other.symlink_target)
174
return self.__class__(
175
self.file_id, self.name, self.parent_id,
180
'directory': GitTreeDirectory,
182
'symlink': GitTreeSymlink,
186
def ensure_normalized_path(path):
187
"""Check whether path is normalized.
189
:raises InvalidNormalization: When path is not normalized, and cannot be
190
accessed on this platform by the normalized path.
191
:return: The NFC normalised version of path.
193
norm_path, can_access = osutils.normalized_filename(path)
194
if norm_path != path:
198
raise errors.InvalidNormalization(path)
202
class GitRevisionTree(revisiontree.RevisionTree):
203
"""Revision tree implementation based on Git objects."""
205
def __init__(self, repository, revision_id):
206
self._revision_id = revision_id
207
self._repository = repository
208
self.store = repository._git.object_store
209
if type(revision_id) is not str:
210
raise TypeError(revision_id)
211
self.commit_id, self.mapping = repository.lookup_bzr_revision_id(revision_id)
212
if revision_id == NULL_REVISION:
214
self.mapping = default_mapping
215
self._fileid_map = GitFileIdMap(
220
commit = self.store[self.commit_id]
222
raise errors.NoSuchRevision(repository, revision_id)
223
self.tree = commit.tree
224
self._fileid_map = self.mapping.get_fileid_map(self.store.__getitem__, self.tree)
226
def supports_rename_tracking(self):
229
def get_file_revision(self, path, file_id=None):
230
change_scanner = self._repository._file_change_scanner
231
if self.commit_id == ZERO_SHA:
233
(path, commit_id) = change_scanner.find_last_change_revision(
234
path.encode('utf-8'), self.commit_id)
235
return self._repository.lookup_foreign_revision_id(commit_id, self.mapping)
237
def get_file_mtime(self, path, file_id=None):
238
revid = self.get_file_revision(path, file_id)
240
rev = self._repository.get_revision(revid)
241
except errors.NoSuchRevision:
242
raise errors.FileTimestampUnavailable(path)
245
def id2path(self, file_id):
247
path = self._fileid_map.lookup_path(file_id)
249
raise errors.NoSuchId(self, file_id)
250
path = path.decode('utf-8')
251
if self.is_versioned(path):
253
raise errors.NoSuchId(self, file_id)
255
def is_versioned(self, path):
256
return self.has_filename(path)
258
def path2id(self, path):
259
if self.mapping.is_special_file(path):
261
return self._fileid_map.lookup_file_id(path.encode('utf-8'))
263
def all_file_ids(self):
264
return set(self._fileid_map.all_file_ids())
266
def all_versioned_paths(self):
268
todo = set([('', self.tree)])
270
(path, tree_id) = todo.pop()
273
tree = self.store[tree_id]
274
for name, mode, hexsha in tree.items():
275
subpath = posixpath.join(path, name)
276
if stat.S_ISDIR(mode):
277
todo.add((subpath, hexsha))
282
def get_root_id(self):
283
if self.tree is None:
285
return self.path2id("")
287
def has_or_had_id(self, file_id):
289
path = self.id2path(file_id)
290
except errors.NoSuchId:
294
def has_id(self, file_id):
296
path = self.id2path(file_id)
297
except errors.NoSuchId:
299
return self.has_filename(path)
301
def _lookup_path(self, path):
302
if self.tree is None:
303
raise errors.NoSuchFile(path)
305
return tree_lookup_path(self.store.__getitem__, self.tree,
306
path.encode('utf-8'))
308
raise errors.NoSuchFile(self, path)
310
def is_executable(self, path, file_id=None):
311
(mode, hexsha) = self._lookup_path(path)
313
# the tree root is a directory
315
return mode_is_executable(mode)
317
def kind(self, path, file_id=None):
318
(mode, hexsha) = self._lookup_path(path)
320
# the tree root is a directory
322
return mode_kind(mode)
324
def has_filename(self, path):
326
self._lookup_path(path)
327
except errors.NoSuchFile:
332
def list_files(self, include_root=False, from_dir=None, recursive=True):
333
if self.tree is None:
337
(mode, hexsha) = self._lookup_path(from_dir)
338
if mode is None: # Root
339
root_ie = self._get_dir_ie(b"", None)
341
parent_path = posixpath.dirname(from_dir.encode("utf-8"))
342
parent_id = self._fileid_map.lookup_file_id(parent_path)
343
if mode_kind(mode) == 'directory':
344
root_ie = self._get_dir_ie(from_dir.encode("utf-8"), parent_id)
346
root_ie = self._get_file_ie(from_dir.encode("utf-8"),
347
posixpath.basename(from_dir), mode, hexsha)
348
if from_dir != "" or include_root:
349
yield (from_dir, "V", root_ie.kind, root_ie.file_id, root_ie)
351
if root_ie.kind == 'directory':
352
todo.add((from_dir.encode("utf-8"), hexsha, root_ie.file_id))
354
(path, hexsha, parent_id) = todo.pop()
355
tree = self.store[hexsha]
356
for name, mode, hexsha in tree.iteritems():
357
if self.mapping.is_special_file(name):
359
child_path = posixpath.join(path, name)
360
if stat.S_ISDIR(mode):
361
ie = self._get_dir_ie(child_path, parent_id)
363
todo.add((child_path, hexsha, ie.file_id))
365
ie = self._get_file_ie(child_path, name, mode, hexsha, parent_id)
366
yield child_path.decode('utf-8'), "V", ie.kind, ie.file_id, ie
368
def _get_file_ie(self, path, name, mode, hexsha, parent_id):
369
if type(path) is not bytes:
370
raise TypeError(path)
371
if type(name) is not bytes:
372
raise TypeError(name)
373
kind = mode_kind(mode)
374
file_id = self._fileid_map.lookup_file_id(path)
375
ie = entry_factory[kind](file_id, name.decode("utf-8"), parent_id)
376
if kind == 'symlink':
377
ie.symlink_target = self.store[hexsha].data.decode('utf-8')
378
elif kind == 'tree-reference':
379
ie.reference_revision = self.mapping.revision_id_foreign_to_bzr(hexsha)
381
data = self.store[hexsha].data
382
ie.text_sha1 = osutils.sha_string(data)
383
ie.text_size = len(data)
384
ie.executable = mode_is_executable(mode)
387
def _get_dir_ie(self, path, parent_id):
388
file_id = self._fileid_map.lookup_file_id(path)
389
return GitTreeDirectory(file_id,
390
posixpath.basename(path).decode("utf-8"), parent_id)
392
def iter_child_entries(self, path, file_id=None):
393
(mode, tree_sha) = self._lookup_path(path)
395
if not stat.S_ISDIR(mode):
398
encoded_path = path.encode('utf-8')
399
file_id = self.path2id(path)
400
tree = self.store[tree_sha]
401
for name, mode, hexsha in tree.iteritems():
402
if self.mapping.is_special_file(name):
404
child_path = posixpath.join(encoded_path, name)
405
if stat.S_ISDIR(mode):
406
yield self._get_dir_ie(child_path, file_id)
408
yield self._get_file_ie(child_path, name, mode, hexsha,
411
def iter_entries_by_dir(self, specific_files=None, yield_parents=False):
412
if self.tree is None:
415
# TODO(jelmer): Support yield parents
416
raise NotImplementedError
417
if specific_files is not None:
418
if specific_files in ([""], []):
419
specific_files = None
421
specific_files = set([p.encode('utf-8') for p in specific_files])
422
todo = set([("", self.tree, None)])
424
path, tree_sha, parent_id = todo.pop()
425
ie = self._get_dir_ie(path, parent_id)
426
if specific_files is None or path in specific_files:
427
yield path.decode("utf-8"), ie
428
tree = self.store[tree_sha]
429
for name, mode, hexsha in tree.iteritems():
430
if self.mapping.is_special_file(name):
432
child_path = posixpath.join(path, name)
433
if stat.S_ISDIR(mode):
434
if (specific_files is None or
435
any(filter(lambda p: p.startswith(child_path), specific_files))):
436
todo.add((child_path, hexsha, ie.file_id))
437
elif specific_files is None or child_path in specific_files:
438
yield (child_path.decode("utf-8"),
439
self._get_file_ie(child_path, name, mode, hexsha,
442
def get_revision_id(self):
443
"""See RevisionTree.get_revision_id."""
444
return self._revision_id
446
def get_file_sha1(self, path, file_id=None, stat_value=None):
447
if self.tree is None:
448
raise errors.NoSuchFile(path)
449
return osutils.sha_string(self.get_file_text(path, file_id))
451
def get_file_verifier(self, path, file_id=None, stat_value=None):
452
(mode, hexsha) = self._lookup_path(path)
453
return ("GIT", hexsha)
455
def get_file_text(self, path, file_id=None):
456
"""See RevisionTree.get_file_text."""
457
(mode, hexsha) = self._lookup_path(path)
458
if stat.S_ISREG(mode):
459
return self.store[hexsha].data
463
def get_symlink_target(self, path, file_id=None):
464
"""See RevisionTree.get_symlink_target."""
465
(mode, hexsha) = self._lookup_path(path)
466
if stat.S_ISLNK(mode):
467
return self.store[hexsha].data.decode('utf-8')
471
def _comparison_data(self, entry, path):
473
return None, False, None
474
return entry.kind, entry.executable, None
476
def path_content_summary(self, path):
477
"""See Tree.path_content_summary."""
479
(mode, hexsha) = self._lookup_path(path)
480
except errors.NoSuchFile:
481
return ('missing', None, None, None)
482
kind = mode_kind(mode)
484
executable = mode_is_executable(mode)
485
contents = self.store[hexsha].data
486
return (kind, len(contents), executable, osutils.sha_string(contents))
487
elif kind == 'symlink':
488
return (kind, None, None, self.store[hexsha].data)
490
return (kind, None, None, None)
492
def find_related_paths_across_trees(self, paths, trees=[],
493
require_versioned=True):
496
if require_versioned:
497
trees = [self] + (trees if trees is not None else [])
501
if t.is_versioned(p):
506
raise errors.PathsNotVersionedError(unversioned)
507
return filter(self.is_versioned, paths)
509
def _iter_tree_contents(self, include_trees=False):
510
if self.tree is None:
512
return self.store.iter_tree_contents(
513
self.tree, include_trees=include_trees)
516
def tree_delta_from_git_changes(changes, mapping,
517
(old_fileid_map, new_fileid_map), specific_files=None,
518
require_versioned=False, include_root=False,
520
"""Create a TreeDelta from two git trees.
522
source and target are iterators over tuples with:
523
(filename, sha, mode)
525
if target_extras is None:
526
target_extras = set()
527
ret = delta.TreeDelta()
528
for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
529
if newpath == u'' and not include_root:
531
if not (specific_files is None or
532
(oldpath is not None and osutils.is_inside_or_parent_of_any(specific_files, oldpath)) or
533
(newpath is not None and osutils.is_inside_or_parent_of_any(specific_files, newpath))):
535
if mapping.is_special_file(oldpath):
537
if mapping.is_special_file(newpath):
539
if oldpath is None and newpath is None:
542
if newpath in target_extras:
543
ret.unversioned.append(
544
(osutils.normalized_filename(newpath)[0], None, mode_kind(newmode)))
546
file_id = new_fileid_map.lookup_file_id(newpath)
547
ret.added.append((newpath.decode('utf-8'), file_id, mode_kind(newmode)))
548
elif newpath is None:
549
file_id = old_fileid_map.lookup_file_id(oldpath)
550
ret.removed.append((oldpath.decode('utf-8'), file_id, mode_kind(oldmode)))
551
elif oldpath != newpath:
552
file_id = old_fileid_map.lookup_file_id(oldpath)
554
(oldpath.decode('utf-8'), newpath.decode('utf-8'), file_id,
555
mode_kind(newmode), (oldsha != newsha),
556
(oldmode != newmode)))
557
elif mode_kind(oldmode) != mode_kind(newmode):
558
file_id = new_fileid_map.lookup_file_id(newpath)
559
ret.kind_changed.append(
560
(newpath.decode('utf-8'), file_id, mode_kind(oldmode),
562
elif oldsha != newsha or oldmode != newmode:
563
if stat.S_ISDIR(oldmode) and stat.S_ISDIR(newmode):
565
file_id = new_fileid_map.lookup_file_id(newpath)
567
(newpath.decode('utf-8'), file_id, mode_kind(newmode),
568
(oldsha != newsha), (oldmode != newmode)))
570
file_id = new_fileid_map.lookup_file_id(newpath)
571
ret.unchanged.append((newpath.decode('utf-8'), file_id, mode_kind(newmode)))
576
def changes_from_git_changes(changes, mapping, specific_files=None, include_unchanged=False,
578
"""Create a iter_changes-like generator from a git stream.
580
source and target are iterators over tuples with:
581
(filename, sha, mode)
583
if target_extras is None:
584
target_extras = set()
585
for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:
586
if not (specific_files is None or
587
(oldpath is not None and osutils.is_inside_or_parent_of_any(specific_files, oldpath)) or
588
(newpath is not None and osutils.is_inside_or_parent_of_any(specific_files, newpath))):
590
path = (oldpath, newpath)
591
if oldpath is not None and mapping.is_special_file(oldpath):
593
if newpath is not None and mapping.is_special_file(newpath):
596
fileid = mapping.generate_file_id(newpath)
604
oldpath = oldpath.decode("utf-8")
606
oldexe = mode_is_executable(oldmode)
607
oldkind = mode_kind(oldmode)
615
(oldparentpath, oldname) = osutils.split(oldpath)
616
oldparent = mapping.generate_file_id(oldparentpath)
617
fileid = mapping.generate_file_id(oldpath)
625
newversioned = (newpath not in target_extras)
627
newexe = mode_is_executable(newmode)
628
newkind = mode_kind(newmode)
632
newpath = newpath.decode("utf-8")
637
newparentpath, newname = osutils.split(newpath)
638
newparent = mapping.generate_file_id(newparentpath)
639
if (not include_unchanged and
640
oldkind == 'directory' and newkind == 'directory' and
643
yield (fileid, (oldpath, newpath), (oldsha != newsha),
644
(oldversioned, newversioned),
645
(oldparent, newparent), (oldname, newname),
646
(oldkind, newkind), (oldexe, newexe))
649
class InterGitTrees(_mod_tree.InterTree):
650
"""InterTree that works between two git trees."""
652
_matching_from_tree_format = None
653
_matching_to_tree_format = None
654
_test_mutable_trees_to_test_trees = None
657
def is_compatible(cls, source, target):
658
return (isinstance(source, GitRevisionTree) and
659
isinstance(target, GitRevisionTree))
661
def compare(self, want_unchanged=False, specific_files=None,
662
extra_trees=None, require_versioned=False, include_root=False,
663
want_unversioned=False):
664
with self.lock_read():
665
changes, target_extras = self._iter_git_changes(
666
want_unchanged=want_unchanged,
667
require_versioned=require_versioned,
668
specific_files=specific_files,
669
extra_trees=extra_trees,
670
want_unversioned=want_unversioned)
671
source_fileid_map = self.source._fileid_map
672
target_fileid_map = self.target._fileid_map
673
return tree_delta_from_git_changes(changes, self.target.mapping,
674
(source_fileid_map, target_fileid_map),
675
specific_files=specific_files, include_root=include_root,
676
target_extras=target_extras)
678
def iter_changes(self, include_unchanged=False, specific_files=None,
679
pb=None, extra_trees=[], require_versioned=True,
680
want_unversioned=False):
681
with self.lock_read():
682
changes, target_extras = self._iter_git_changes(
683
want_unchanged=include_unchanged,
684
require_versioned=require_versioned,
685
specific_files=specific_files,
686
extra_trees=extra_trees,
687
want_unversioned=want_unversioned)
688
return changes_from_git_changes(
689
changes, self.target.mapping,
690
specific_files=specific_files,
691
include_unchanged=include_unchanged,
692
target_extras=target_extras)
694
def _iter_git_changes(self, want_unchanged=False, specific_files=None,
695
require_versioned=False, extra_trees=None,
696
want_unversioned=False):
697
raise NotImplementedError(self._iter_git_changes)
700
class InterGitRevisionTrees(InterGitTrees):
701
"""InterTree that works between two git revision trees."""
703
_matching_from_tree_format = None
704
_matching_to_tree_format = None
705
_test_mutable_trees_to_test_trees = None
708
def is_compatible(cls, source, target):
709
return (isinstance(source, GitRevisionTree) and
710
isinstance(target, GitRevisionTree))
712
def _iter_git_changes(self, want_unchanged=False, specific_files=None,
713
require_versioned=True, extra_trees=None,
714
want_unversioned=False):
715
trees = [self.source]
716
if extra_trees is not None:
717
trees.extend(extra_trees)
718
if specific_files is not None:
719
specific_files = self.target.find_related_paths_across_trees(
720
specific_files, trees,
721
require_versioned=require_versioned)
723
if self.source._repository._git.object_store != self.target._repository._git.object_store:
724
store = OverlayObjectStore([self.source._repository._git.object_store,
725
self.target._repository._git.object_store])
727
store = self.source._repository._git.object_store
728
return self.source._repository._git.object_store.tree_changes(
729
self.source.tree, self.target.tree, want_unchanged=want_unchanged,
730
include_trees=True, change_type_same=True), set()
733
_mod_tree.InterTree.register_optimiser(InterGitRevisionTrees)
736
class MutableGitIndexTree(mutabletree.MutableTree):
739
self._lock_mode = None
741
self._versioned_dirs = None
743
def is_versioned(self, path):
744
with self.lock_read():
745
path = path.rstrip('/').encode('utf-8')
746
return (path in self.index or self._has_dir(path))
748
def _has_dir(self, path):
751
if self._versioned_dirs is None:
753
return path in self._versioned_dirs
755
def _load_dirs(self):
756
if self._lock_mode is None:
757
raise errors.ObjectNotLocked(self)
758
self._versioned_dirs = set()
760
self._ensure_versioned_dir(posixpath.dirname(p))
762
def _ensure_versioned_dir(self, dirname):
763
if dirname in self._versioned_dirs:
766
self._ensure_versioned_dir(posixpath.dirname(dirname))
767
self._versioned_dirs.add(dirname)
769
def path2id(self, path):
770
with self.lock_read():
771
path = path.rstrip('/')
772
if self.is_versioned(path.rstrip('/')):
773
return self._fileid_map.lookup_file_id(path.encode("utf-8"))
776
def has_id(self, file_id):
778
self.id2path(file_id)
779
except errors.NoSuchId:
784
def id2path(self, file_id):
787
if type(file_id) is not bytes:
788
raise TypeError(file_id)
789
with self.lock_read():
791
path = self._fileid_map.lookup_path(file_id)
793
raise errors.NoSuchId(self, file_id)
794
path = path.decode('utf-8')
795
if self.is_versioned(path):
797
raise errors.NoSuchId(self, file_id)
799
def _set_root_id(self, file_id):
800
self._fileid_map.set_file_id("", file_id)
802
def get_root_id(self):
803
return self.path2id("")
805
def _add(self, files, ids, kinds):
806
for (path, file_id, kind) in zip(files, ids, kinds):
807
if file_id is not None:
808
raise workingtree.SettingFileIdUnsupported()
809
path, can_access = osutils.normalized_filename(path)
811
raise errors.InvalidNormalization(path)
812
self._index_add_entry(path, kind)
814
def _index_add_entry(self, path, kind, flags=0):
815
if not isinstance(path, basestring):
816
raise TypeError(path)
817
if kind == "directory":
818
# Git indexes don't contain directories
823
file, stat_val = self.get_file_with_stat(path)
824
except (errors.NoSuchFile, IOError):
825
# TODO: Rather than come up with something here, use the old index
827
stat_val = os.stat_result(
828
(stat.S_IFREG | 0644, 0, 0, 0, 0, 0, 0, 0, 0, 0))
829
blob.set_raw_string(file.read())
830
elif kind == "symlink":
833
stat_val = self._lstat(path)
834
except (errors.NoSuchFile, OSError):
835
# TODO: Rather than come up with something here, use the
837
stat_val = os.stat_result(
838
(stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
840
self.get_symlink_target(path).encode("utf-8"))
842
raise AssertionError("unknown kind '%s'" % kind)
843
# Add object to the repository if it didn't exist yet
844
if not blob.id in self.store:
845
self.store.add_object(blob)
846
# Add an entry to the index or update the existing entry
847
ensure_normalized_path(path)
848
encoded_path = path.encode("utf-8")
849
if b'\r' in encoded_path or b'\n' in encoded_path:
850
# TODO(jelmer): Why do we need to do this?
851
trace.mutter('ignoring path with invalid newline in it: %r', path)
853
self.index[encoded_path] = index_entry_from_stat(
854
stat_val, blob.id, flags)
855
if self._versioned_dirs is not None:
856
self._ensure_versioned_dir(encoded_path)
858
def iter_entries_by_dir(self, specific_files=None, yield_parents=False):
860
raise NotImplementedError(self.iter_entries_by_dir)
861
with self.lock_read():
862
if specific_files is not None:
863
specific_files = set(specific_files)
865
specific_files = None
866
root_ie = self._get_dir_ie(u"", None)
868
if specific_files is None or u"" in specific_files:
869
ret[(None, u"")] = root_ie
870
dir_ids = {u"": root_ie.file_id}
871
for path, value in self.index.iteritems():
872
if self.mapping.is_special_file(path):
874
path = path.decode("utf-8")
875
if specific_files is not None and not path in specific_files:
877
(parent, name) = posixpath.split(path)
879
file_ie = self._get_file_ie(name, path, value, None)
880
except errors.NoSuchFile:
882
if yield_parents or specific_files is None:
883
for (dir_path, dir_ie) in self._add_missing_parent_ids(parent,
885
ret[(posixpath.dirname(dir_path), dir_path)] = dir_ie
886
file_ie.parent_id = self.path2id(parent)
887
ret[(posixpath.dirname(path), path)] = file_ie
888
return ((path, ie) for ((_, path), ie) in sorted(ret.items()))
891
def _get_dir_ie(self, path, parent_id):
892
file_id = self.path2id(path)
893
return GitTreeDirectory(file_id,
894
posixpath.basename(path).strip("/"), parent_id)
896
def _get_file_ie(self, name, path, value, parent_id):
897
if type(name) is not unicode:
898
raise TypeError(name)
899
if type(path) is not unicode:
900
raise TypeError(path)
901
if not isinstance(value, tuple) or len(value) != 10:
902
raise TypeError(value)
903
(ctime, mtime, dev, ino, mode, uid, gid, size, sha, flags) = value
904
file_id = self.path2id(path)
905
if type(file_id) != str:
907
kind = mode_kind(mode)
908
ie = entry_factory[kind](file_id, name, parent_id)
909
if kind == 'symlink':
910
ie.symlink_target = self.get_symlink_target(path, file_id)
913
data = self.get_file_text(path, file_id)
914
except errors.NoSuchFile:
917
if e.errno != errno.ENOENT:
921
data = self.branch.repository._git.object_store[sha].data
922
ie.text_sha1 = osutils.sha_string(data)
923
ie.text_size = len(data)
924
ie.executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
927
def _add_missing_parent_ids(self, path, dir_ids):
930
parent = posixpath.dirname(path).strip("/")
931
ret = self._add_missing_parent_ids(parent, dir_ids)
932
parent_id = dir_ids[parent]
933
ie = self._get_dir_ie(path, parent_id)
934
dir_ids[path] = ie.file_id
935
ret.append((path, ie))
938
def _comparison_data(self, entry, path):
940
return None, False, None
941
return entry.kind, entry.executable, None
943
def _unversion_path(self, path):
944
if self._lock_mode is None:
945
raise errors.ObjectNotLocked(self)
946
encoded_path = path.encode("utf-8")
949
del self.index[encoded_path]
951
# A directory, perhaps?
952
for p in list(self.index):
953
if p.startswith(encoded_path+b"/"):
958
self._versioned_dirs = None
961
def unversion(self, paths, file_ids=None):
962
with self.lock_tree_write():
964
if self._unversion_path(path) == 0:
965
raise errors.NoSuchFile(path)
966
self._versioned_dirs = None
972
def update_basis_by_delta(self, revid, delta):
973
# TODO(jelmer): This shouldn't be called, it's inventory specific.
974
for (old_path, new_path, file_id, ie) in delta:
975
if old_path is not None and old_path.encode('utf-8') in self.index:
976
del self.index[old_path.encode('utf-8')]
977
self._versioned_dirs = None
978
if new_path is not None and ie.kind != 'directory':
979
self._index_add_entry(new_path, ie.kind)
981
self._set_merges_from_parent_ids([])
983
def move(self, from_paths, to_dir=None, after=None):
985
with self.lock_tree_write():
986
to_abs = self.abspath(to_dir)
987
if not os.path.isdir(to_abs):
988
raise errors.BzrMoveFailedError('', to_dir,
989
errors.NotADirectory(to_abs))
991
for from_rel in from_paths:
992
from_tail = os.path.split(from_rel)[-1]
993
to_rel = os.path.join(to_dir, from_tail)
994
self.rename_one(from_rel, to_rel, after=after)
995
rename_tuples.append((from_rel, to_rel))
999
def rename_one(self, from_rel, to_rel, after=None):
1000
from_path = from_rel.encode("utf-8")
1001
to_rel, can_access = osutils.normalized_filename(to_rel)
1003
raise errors.InvalidNormalization(to_rel)
1004
to_path = to_rel.encode("utf-8")
1005
with self.lock_tree_write():
1007
# Perhaps it's already moved?
1009
not self.has_filename(from_rel) and
1010
self.has_filename(to_rel) and
1011
not self.is_versioned(to_rel))
1013
if not self.has_filename(to_rel):
1014
raise errors.BzrMoveFailedError(from_rel, to_rel,
1015
errors.NoSuchFile(to_rel))
1016
if self.basis_tree().is_versioned(to_rel):
1017
raise errors.BzrMoveFailedError(from_rel, to_rel,
1018
errors.AlreadyVersionedError(to_rel))
1020
kind = self.kind(to_rel)
1023
to_kind = self.kind(to_rel)
1024
except errors.NoSuchFile:
1025
exc_type = errors.BzrRenameFailedError
1028
exc_type = errors.BzrMoveFailedError
1029
if self.is_versioned(to_rel):
1030
raise exc_type(from_rel, to_rel,
1031
errors.AlreadyVersionedError(to_rel))
1032
if not self.has_filename(from_rel):
1033
raise errors.BzrMoveFailedError(from_rel, to_rel,
1034
errors.NoSuchFile(from_rel))
1035
kind = self.kind(from_rel)
1036
if not self.is_versioned(from_rel) and kind != 'directory':
1037
raise exc_type(from_rel, to_rel,
1038
errors.NotVersionedError(from_rel))
1039
if self.has_filename(to_rel):
1040
raise errors.RenameFailedFilesExist(
1041
from_rel, to_rel, errors.FileExists(to_rel))
1043
kind = self.kind(from_rel)
1045
if not after and not from_path in self.index and kind != 'directory':
1047
raise errors.BzrMoveFailedError(from_rel, to_rel,
1048
errors.NotVersionedError(path=from_rel))
1052
self._rename_one(from_rel, to_rel)
1053
except OSError as e:
1054
if e.errno == errno.ENOENT:
1055
raise errors.BzrMoveFailedError(from_rel, to_rel,
1056
errors.NoSuchFile(to_rel))
1058
if kind != 'directory':
1060
del self.index[from_path]
1063
self._index_add_entry(to_rel, kind)
1065
todo = [p for p in self.index if p.startswith(from_path+'/')]
1067
self.index[posixpath.join(to_path, posixpath.relpath(p, from_path))] = self.index[p]
1070
self._versioned_dirs = None
1073
def find_related_paths_across_trees(self, paths, trees=[],
1074
require_versioned=True):
1078
if require_versioned:
1079
trees = [self] + (trees if trees is not None else [])
1083
if t.is_versioned(p):
1088
raise errors.PathsNotVersionedError(unversioned)
1090
return filter(self.is_versioned, paths)
added
removed
tree.py
