/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/tree.py

  • Committer: Jelmer Vernooij
  • Date: 2020-08-22 22:46:24 UTC
  • mfrom: (7490.40.105 work)
  • mto: This revision was merged to the branch mainline in revision 7521.
  • Revision ID: jelmer@jelmer.uk-20200822224624-om4a4idsr7cn8jew
merge lp:brz/3.1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/tree.py
272
272
        """
273
273
        raise NotImplementedError(self.snapshot)
274
274
 
 
275
    def preview_transform(self, pb=None):
 
276
        from .transform import GitTransformPreview
 
277
        return GitTransformPreview(self, pb=pb)
 
278
 
 
279
    def find_related_paths_across_trees(self, paths, trees=[],
 
280
                                        require_versioned=True):
 
281
        if paths is None:
 
282
            return None
 
283
        if require_versioned:
 
284
            trees = [self] + (trees if trees is not None else [])
 
285
            unversioned = set()
 
286
            for p in paths:
 
287
                for t in trees:
 
288
                    if t.is_versioned(p):
 
289
                        break
 
290
                else:
 
291
                    unversioned.add(p)
 
292
            if unversioned:
 
293
                raise errors.PathsNotVersionedError(unversioned)
 
294
        return filter(self.is_versioned, paths)
 
295
 
 
296
    def _submodule_info(self):
 
297
        if self._submodules is None:
 
298
            try:
 
299
                with self.get_file('.gitmodules') as f:
 
300
                    config = GitConfigFile.from_file(f)
 
301
                    self._submodules = {
 
302
                        path: (url, section)
 
303
                        for path, url, section in parse_submodules(config)}
 
304
            except errors.NoSuchFile:
 
305
                self._submodules = {}
 
306
        return self._submodules
 
307
 
275
308
 
276
309
class GitRevisionTree(revisiontree.RevisionTree, GitTree):
277
310
    """Revision tree implementation based on Git objects."""
298
331
    def git_snapshot(self, want_unversioned=False):
299
332
        return self.tree, set()
300
333
 
301
 
    def _submodule_info(self):
302
 
        if self._submodules is None:
303
 
            try:
304
 
                with self.get_file('.gitmodules') as f:
305
 
                    config = GitConfigFile.from_file(f)
306
 
                    self._submodules = {
307
 
                        path: (url, section)
308
 
                        for path, url, section in parse_submodules(config)}
309
 
            except errors.NoSuchFile:
310
 
                self._submodules = {}
311
 
        return self._submodules
312
 
 
313
334
    def _get_submodule_repository(self, relpath):
314
335
        if not isinstance(relpath, bytes):
315
336
            raise TypeError(relpath)
440
461
        else:
441
462
            return True
442
463
 
443
 
    def _submodule_info(self):
444
 
        if self._submodules is None:
445
 
            try:
446
 
                with self.get_file('.gitmodules') as f:
447
 
                    config = GitConfigFile.from_file(f)
448
 
                    self._submodules = {
449
 
                        path: (url, section)
450
 
                        for path, url, section in parse_submodules(config)}
451
 
            except errors.NoSuchFile:
452
 
                self._submodules = {}
453
 
        return self._submodules
454
 
 
455
464
    def list_files(self, include_root=False, from_dir=None, recursive=True,
456
465
                   recurse_nested=False):
457
466
        if self.tree is None:
667
676
        else:
668
677
            return (kind, None, None, None)
669
678
 
670
 
    def find_related_paths_across_trees(self, paths, trees=[],
671
 
                                        require_versioned=True):
672
 
        if paths is None:
673
 
            return None
674
 
        if require_versioned:
675
 
            trees = [self] + (trees if trees is not None else [])
676
 
            unversioned = set()
677
 
            for p in paths:
678
 
                for t in trees:
679
 
                    if t.is_versioned(p):
680
 
                        break
681
 
                else:
682
 
                    unversioned.add(p)
683
 
            if unversioned:
684
 
                raise errors.PathsNotVersionedError(unversioned)
685
 
        return filter(self.is_versioned, paths)
686
 
 
687
679
    def _iter_tree_contents(self, include_trees=False):
688
680
        if self.tree is None:
689
681
            return iter([])
735
727
                        mode_kind(mode)))
736
728
            yield path_decoded, children
737
729
 
738
 
    def preview_transform(self, pb=None):
739
 
        from .transform import GitTransformPreview
740
 
        return GitTransformPreview(self, pb=pb)
741
 
 
742
730
 
743
731
def tree_delta_from_git_changes(changes, mappings,
744
732
                                specific_files=None,
973
961
            fileid = mapping.generate_file_id(newpath_decoded)
974
962
        else:
975
963
            fileid = None
 
964
        if oldkind == 'directory' and newkind == 'directory':
 
965
            modified = False
 
966
        else:
 
967
            modified = (oldsha != newsha) or (oldmode != newmode)
976
968
        yield InventoryTreeChange(
977
 
            fileid, (oldpath_decoded, newpath_decoded), (oldsha != newsha),
 
969
            fileid, (oldpath_decoded, newpath_decoded),
 
970
            modified,
978
971
            (oldversioned, newversioned),
979
972
            (oldparent, newparent), (oldname, newname),
980
973
            (oldkind, newkind), (oldexe, newexe),
1193
1186
    def _read_submodule_head(self, path):
1194
1187
        raise NotImplementedError(self._read_submodule_head)
1195
1188
 
1196
 
    def _submodule_info(self):
1197
 
        if self._submodules is None:
1198
 
            try:
1199
 
                with self.get_file('.gitmodules') as f:
1200
 
                    config = GitConfigFile.from_file(f)
1201
 
                    self._submodules = {
1202
 
                        path: (url, section)
1203
 
                        for path, url, section in parse_submodules(config)}
1204
 
            except errors.NoSuchFile:
1205
 
                self._submodules = {}
1206
 
        return self._submodules
1207
 
 
1208
1189
    def _lookup_index(self, encoded_path):
1209
1190
        if not isinstance(encoded_path, bytes):
1210
1191
            raise TypeError(encoded_path)
1240
1221
        # TODO(jelmer): Keep track of dirty per index
1241
1222
        self._index_dirty = True
1242
1223
 
1243
 
    def _index_add_entry(self, path, kind, flags=0, reference_revision=None):
 
1224
    def _apply_index_changes(self, changes):
 
1225
        for (path, kind, executability, reference_revision,
 
1226
             symlink_target) in changes:
 
1227
            if kind is None or kind == 'directory':
 
1228
                (index, subpath) = self._lookup_index(
 
1229
                    encode_git_path(path))
 
1230
                try:
 
1231
                    self._index_del_entry(index, subpath)
 
1232
                except KeyError:
 
1233
                    pass
 
1234
                else:
 
1235
                    self._versioned_dirs = None
 
1236
            else:
 
1237
                self._index_add_entry(
 
1238
                    path, kind,
 
1239
                    reference_revision=reference_revision,
 
1240
                    symlink_target=symlink_target)
 
1241
        self.flush()
 
1242
 
 
1243
    def _index_add_entry(
 
1244
            self, path, kind, flags=0, reference_revision=None,
 
1245
            symlink_target=None):
1244
1246
        if kind == "directory":
1245
1247
            # Git indexes don't contain directories
1246
1248
            return
1247
 
        if kind == "file":
 
1249
        elif kind == "file":
1248
1250
            blob = Blob()
1249
1251
            try:
1250
1252
                file, stat_val = self.get_file_with_stat(path)
1269
1271
                # old index
1270
1272
                stat_val = os.stat_result(
1271
1273
                    (stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
1272
 
            blob.set_raw_string(encode_git_path(self.get_symlink_target(path)))
 
1274
            if symlink_target is None:
 
1275
                symlink_target = self.get_symlink_target(path)
 
1276
            blob.set_raw_string(encode_git_path(symlink_target))
1273
1277
            # Add object to the repository if it didn't exist yet
1274
1278
            if blob.id not in self.store:
1275
1279
                self.store.add_object(blob)
1561
1565
            self._versioned_dirs = None
1562
1566
            self.flush()
1563
1567
 
1564
 
    def find_related_paths_across_trees(self, paths, trees=[],
1565
 
                                        require_versioned=True):
1566
 
        if paths is None:
1567
 
            return None
1568
 
 
1569
 
        if require_versioned:
1570
 
            trees = [self] + (trees if trees is not None else [])
1571
 
            unversioned = set()
1572
 
            for p in paths:
1573
 
                for t in trees:
1574
 
                    if t.is_versioned(p):
1575
 
                        break
1576
 
                else:
1577
 
                    unversioned.add(p)
1578
 
            if unversioned:
1579
 
                raise errors.PathsNotVersionedError(unversioned)
1580
 
 
1581
 
        return filter(self.is_versioned, paths)
1582
 
 
1583
1568
    def path_content_summary(self, path):
1584
1569
        """See Tree.path_content_summary."""
1585
1570
        try:
1606
1591
            return (kind, None, None, None)
1607
1592
 
1608
1593
    def stored_kind(self, relpath):
 
1594
        if relpath == '':
 
1595
            return 'directory'
1609
1596
        (index, index_path) = self._lookup_index(encode_git_path(relpath))
1610
1597
        if index is None:
1611
 
            return kind
 
1598
            return None
1612
1599
        try:
1613
1600
            mode = index[index_path].mode
1614
1601
        except KeyError:
1615
 
            return kind
 
1602
            for p in index:
 
1603
                if osutils.is_inside(
 
1604
                        decode_git_path(index_path), decode_git_path(p)):
 
1605
                    return 'directory'
 
1606
            return None
1616
1607
        else:
1617
 
            if S_ISGITLINK(mode):
1618
 
                return 'tree-reference'
1619
 
            return 'directory'
 
1608
            return mode_kind(mode)
1620
1609
 
1621
1610
    def kind(self, relpath):
1622
1611
        kind = osutils.file_kind(self.abspath(relpath))
1634
1623
        from .transform import GitTreeTransform
1635
1624
        return GitTreeTransform(self, pb=pb)
1636
1625
 
1637
 
    def preview_transform(self, pb=None):
1638
 
        from .transform import GitTransformPreview
1639
 
        return GitTransformPreview(self, pb=pb)
1640
 
 
1641
1626
    def has_changes(self, _from_tree=None):
1642
1627
        """Quickly check that the tree contains at least one commitable change.
1643
1628