/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

Update the GitTreeTransform to not use file ids internally.

Merged from https://code.launchpad.net/~jelmer/brz/transform/+merge/389623

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/tree.py
278
278
        """
279
279
        raise NotImplementedError(self.snapshot)
280
280
 
 
281
    def preview_transform(self, pb=None):
 
282
        from .transform import GitTransformPreview
 
283
        return GitTransformPreview(self, pb=pb)
 
284
 
 
285
    def find_related_paths_across_trees(self, paths, trees=[],
 
286
                                        require_versioned=True):
 
287
        if paths is None:
 
288
            return None
 
289
        if require_versioned:
 
290
            trees = [self] + (trees if trees is not None else [])
 
291
            unversioned = set()
 
292
            for p in paths:
 
293
                for t in trees:
 
294
                    if t.is_versioned(p):
 
295
                        break
 
296
                else:
 
297
                    unversioned.add(p)
 
298
            if unversioned:
 
299
                raise errors.PathsNotVersionedError(unversioned)
 
300
        return filter(self.is_versioned, paths)
 
301
 
281
302
    def _submodule_info(self):
282
303
        if self._submodules is None:
283
304
            try:
661
682
        else:
662
683
            return (kind, None, None, None)
663
684
 
664
 
    def find_related_paths_across_trees(self, paths, trees=[],
665
 
                                        require_versioned=True):
666
 
        if paths is None:
667
 
            return None
668
 
        if require_versioned:
669
 
            trees = [self] + (trees if trees is not None else [])
670
 
            unversioned = set()
671
 
            for p in paths:
672
 
                for t in trees:
673
 
                    if t.is_versioned(p):
674
 
                        break
675
 
                else:
676
 
                    unversioned.add(p)
677
 
            if unversioned:
678
 
                raise errors.PathsNotVersionedError(unversioned)
679
 
        return filter(self.is_versioned, paths)
680
 
 
681
685
    def _iter_tree_contents(self, include_trees=False):
682
686
        if self.tree is None:
683
687
            return iter([])
729
733
                        mode_kind(mode)))
730
734
            yield path_decoded, children
731
735
 
732
 
    def preview_transform(self, pb=None):
733
 
        from .transform import GitTransformPreview
734
 
        return GitTransformPreview(self, pb=pb)
735
 
 
736
736
 
737
737
def tree_delta_from_git_changes(changes, mappings,
738
738
                                specific_files=None,
967
967
            fileid = mapping.generate_file_id(newpath_decoded)
968
968
        else:
969
969
            fileid = None
 
970
        if oldkind == 'directory' and newkind == 'directory':
 
971
            modified = False
 
972
        else:
 
973
            modified = (oldsha != newsha) or (oldmode != newmode)
970
974
        yield InventoryTreeChange(
971
 
            fileid, (oldpath_decoded, newpath_decoded), (oldsha != newsha),
 
975
            fileid, (oldpath_decoded, newpath_decoded),
 
976
            modified,
972
977
            (oldversioned, newversioned),
973
978
            (oldparent, newparent), (oldname, newname),
974
979
            (oldkind, newkind), (oldexe, newexe),
1222
1227
        # TODO(jelmer): Keep track of dirty per index
1223
1228
        self._index_dirty = True
1224
1229
 
1225
 
    def _index_add_entry(self, path, kind, flags=0, reference_revision=None):
 
1230
    def _apply_index_changes(self, changes):
 
1231
        for (path, kind, executability, reference_revision,
 
1232
             symlink_target) in changes:
 
1233
            if kind is None or kind == 'directory':
 
1234
                (index, subpath) = self._lookup_index(
 
1235
                    encode_git_path(path))
 
1236
                try:
 
1237
                    self._index_del_entry(index, subpath)
 
1238
                except KeyError:
 
1239
                    pass
 
1240
                else:
 
1241
                    self._versioned_dirs = None
 
1242
            else:
 
1243
                self._index_add_entry(
 
1244
                    path, kind,
 
1245
                    reference_revision=reference_revision,
 
1246
                    symlink_target=symlink_target)
 
1247
        self.flush()
 
1248
 
 
1249
    def _index_add_entry(
 
1250
            self, path, kind, flags=0, reference_revision=None,
 
1251
            symlink_target=None):
1226
1252
        if kind == "directory":
1227
1253
            # Git indexes don't contain directories
1228
1254
            return
1229
 
        if kind == "file":
 
1255
        elif kind == "file":
1230
1256
            blob = Blob()
1231
1257
            try:
1232
1258
                file, stat_val = self.get_file_with_stat(path)
1251
1277
                # old index
1252
1278
                stat_val = os.stat_result(
1253
1279
                    (stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
1254
 
            blob.set_raw_string(encode_git_path(self.get_symlink_target(path)))
 
1280
            if symlink_target is None:
 
1281
                symlink_target = self.get_symlink_target(path)
 
1282
            blob.set_raw_string(encode_git_path(symlink_target))
1255
1283
            # Add object to the repository if it didn't exist yet
1256
1284
            if blob.id not in self.store:
1257
1285
                self.store.add_object(blob)
1543
1571
            self._versioned_dirs = None
1544
1572
            self.flush()
1545
1573
 
1546
 
    def find_related_paths_across_trees(self, paths, trees=[],
1547
 
                                        require_versioned=True):
1548
 
        if paths is None:
1549
 
            return None
1550
 
 
1551
 
        if require_versioned:
1552
 
            trees = [self] + (trees if trees is not None else [])
1553
 
            unversioned = set()
1554
 
            for p in paths:
1555
 
                for t in trees:
1556
 
                    if t.is_versioned(p):
1557
 
                        break
1558
 
                else:
1559
 
                    unversioned.add(p)
1560
 
            if unversioned:
1561
 
                raise errors.PathsNotVersionedError(unversioned)
1562
 
 
1563
 
        return filter(self.is_versioned, paths)
1564
 
 
1565
1574
    def path_content_summary(self, path):
1566
1575
        """See Tree.path_content_summary."""
1567
1576
        try:
1588
1597
            return (kind, None, None, None)
1589
1598
 
1590
1599
    def stored_kind(self, relpath):
 
1600
        if relpath == '':
 
1601
            return 'directory'
1591
1602
        (index, index_path) = self._lookup_index(encode_git_path(relpath))
1592
1603
        if index is None:
1593
 
            return kind
 
1604
            return None
1594
1605
        try:
1595
1606
            mode = index[index_path].mode
1596
1607
        except KeyError:
1597
 
            return kind
 
1608
            for p in index:
 
1609
                if osutils.is_inside(
 
1610
                        decode_git_path(index_path), decode_git_path(p)):
 
1611
                    return 'directory'
 
1612
            return None
1598
1613
        else:
1599
 
            if S_ISGITLINK(mode):
1600
 
                return 'tree-reference'
1601
 
            return 'directory'
 
1614
            return mode_kind(mode)
1602
1615
 
1603
1616
    def kind(self, relpath):
1604
1617
        kind = osutils.file_kind(self.abspath(relpath))
1616
1629
        from .transform import GitTreeTransform
1617
1630
        return GitTreeTransform(self, pb=pb)
1618
1631
 
1619
 
    def preview_transform(self, pb=None):
1620
 
        from .transform import GitTransformPreview
1621
 
        return GitTransformPreview(self, pb=pb)
1622
 
 
1623
1632
    def has_changes(self, _from_tree=None):
1624
1633
        """Quickly check that the tree contains at least one commitable change.
1625
1634