/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 workingtree.py

  • Committer: Jelmer Vernooij
  • Date: 2009-09-10 13:13:15 UTC
  • mto: (0.200.602 trunk)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@samba.org-20090910131315-6890xg58pl2jseml
Allow serving remote URLs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
workingtree.py
25
25
from dulwich.objects import (
26
26
    Blob,
27
27
    )
28
 
from dulwich.protocol import (
29
 
    ZERO_SHA,
30
 
    )
31
28
import os
32
29
import stat
33
30
 
34
31
from bzrlib import (
35
32
    errors,
36
33
    ignores,
37
 
    inventory,
38
34
    lockable_files,
39
35
    lockdir,
40
36
    osutils,
41
37
    transport,
42
38
    tree,
 
39
    urlutils,
43
40
    workingtree,
44
41
    )
45
42
from bzrlib.decorators import (
50
47
from bzrlib.plugins.git.inventory import (
51
48
    GitIndexInventory,
52
49
    )
53
 
from bzrlib.plugins.git.tree import (
54
 
    changes_from_git_changes,
55
 
    tree_delta_from_git_changes,
56
 
    )
57
50
 
58
51
 
59
52
IGNORE_FILENAME = ".gitignore"
62
55
class GitWorkingTree(workingtree.WorkingTree):
63
56
    """A Git working tree."""
64
57
 
65
 
    def __init__(self, bzrdir, repo, branch, index):
 
58
    def __init__(self, bzrdir, repo, branch):
66
59
        self.basedir = bzrdir.root_transport.local_abspath('.')
67
60
        self.bzrdir = bzrdir
68
61
        self.repository = repo
70
63
        self._branch = branch
71
64
        self._transport = bzrdir.transport
72
65
 
73
 
        self.controldir = self.bzrdir.transport.local_abspath('bzr')
 
66
        self.controldir = urlutils.join(self.repository._git._controldir, 'bzr')
74
67
 
75
68
        try:
76
69
            os.makedirs(self.controldir)
81
74
        self._control_files = lockable_files.LockableFiles(
82
75
            transport.get_transport(self.controldir), 'lock', lockdir.LockDir)
83
76
        self._format = GitWorkingTreeFormat()
84
 
        self.index = index
 
77
        self.index = self.repository._git.open_index()
85
78
        self.views = self._make_views()
86
79
        self._detect_case_handling()
87
80
 
88
 
    def extras(self):
89
 
        """Yield all unversioned files in this WorkingTree.
90
 
        """
91
 
        for (dirpath, dirnames, filenames) in os.walk(self.basedir):
92
 
            if self.bzrdir.is_control_filename(dirpath[len(self.basedir):].strip("/")):
93
 
                continue
94
 
            for filename in filenames:
95
 
                relpath = os.path.join(dirpath[len(self.basedir):].strip("/"), filename)
96
 
                if not relpath in self.index:
97
 
                    yield relpath
98
 
 
99
 
 
100
81
    def unlock(self):
101
82
        # non-implementation specific cleanup
102
83
        self._cleanup()
136
117
                    from posix import stat_result
137
118
                    stat_val = stat_result((stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
138
119
                blob.set_raw_string(entry.symlink_target)
139
 
            else:
140
 
                raise AssertionError("unknown kind '%s'" % entry.kind)
141
120
            # Add object to the repository if it didn't exist yet
142
121
            if not blob.id in self.repository._git.object_store:
143
122
                self.repository._git.object_store.add_object(blob)
175
154
 
176
155
    def _reset_data(self):
177
156
        self._inventory_is_modified = False
178
 
        try:
179
 
            head = self.repository._git.head()
180
 
        except KeyError, name:
181
 
            raise errors.NotBranchError("branch %s at %s" % (name, self.repository.base))
182
 
        basis_inv = self.repository.get_inventory(self.branch.lookup_foreign_revision_id(head))
183
 
        store = self.repository._git.object_store
184
 
        if head == ZERO_SHA:
185
 
            fileid_map = {}
186
 
            result = inventory.Inventory(root_id=None)
187
 
        else:
188
 
            fileid_map = self.mapping.get_fileid_map(store.__getitem__,
189
 
                store[head].tree)
190
 
            result = GitIndexInventory(basis_inv, fileid_map, self.index, store)
 
157
        basis_inv = self.repository.get_inventory(self.mapping.revision_id_foreign_to_bzr(self.repository._git.head()))
 
158
        result = GitIndexInventory(basis_inv, self.mapping, self.index,
 
159
            self.repository._git.object_store)
191
160
        self._set_inventory(result, dirty=False)
192
161
 
193
162
    @needs_read_lock
201
170
                return None
202
171
            raise
203
172
 
204
 
    def revision_tree(self, revid):
205
 
        return self.repository.revision_tree(revid)
 
173
    def iter_changes(self, from_tree, include_unchanged=False,
 
174
                     specific_files=None, pb=None, extra_trees=None,
 
175
                     require_versioned=True, want_unversioned=False):
206
176
 
207
 
    @needs_read_lock
208
 
    def conflicts(self):
209
 
        # FIXME:
210
 
        return []
 
177
        intertree = tree.InterTree.get(from_tree, self)
 
178
        return intertree.iter_changes(include_unchanged, specific_files, pb,
 
179
            extra_trees, require_versioned, want_unversioned=want_unversioned)
211
180
 
212
181
 
213
182
class GitWorkingTreeFormat(workingtree.WorkingTreeFormat):
214
183
 
215
 
    @property
216
 
    def _matchingbzrdir(self):
217
 
        from bzrlib.plugins.git import LocalGitBzrDirFormat
218
 
        return LocalGitBzrDirFormat()
219
 
 
220
184
    def get_format_description(self):
221
185
        return "Git Working Tree"
222
 
 
223
 
 
224
 
class InterIndexGitTree(tree.InterTree):
225
 
    """InterTree that works between a Git revision tree and an index."""
226
 
 
227
 
    def __init__(self, source, target):
228
 
        super(InterIndexGitTree, self).__init__(source, target)
229
 
        self._index = target.index
230
 
 
231
 
    @classmethod
232
 
    def is_compatible(cls, source, target):
233
 
        from bzrlib.plugins.git.repository import GitRevisionTree
234
 
        return (isinstance(source, GitRevisionTree) and 
235
 
                isinstance(target, GitWorkingTree))
236
 
 
237
 
    def compare(self, want_unchanged=False, specific_files=None,
238
 
                extra_trees=None, require_versioned=False, include_root=False,
239
 
                want_unversioned=False):
240
 
        changes = self._index.changes_from_tree(
241
 
            self.source._repository._git.object_store, self.source.tree, 
242
 
            want_unchanged=want_unchanged)
243
 
        source_fileid_map = self.source.mapping.get_fileid_map(
244
 
            self.source._repository._git.object_store.__getitem__,
245
 
            self.source.tree)
246
 
        if self.target.mapping.BZR_FILE_IDS_FILE is not None:
247
 
            try:
248
 
                file_id = self.target.path2id(
249
 
                    self.target.mapping.BZR_FILE_IDS_FILE)
250
 
            except errors.NoSuchId:
251
 
                target_fileid_map = {}
252
 
            else:
253
 
                target_fileid_map = self.import_fileid_map(Blob.from_string(self.target.file_text(file_id)))
254
 
        else:
255
 
            target_fileid_map = {}
256
 
        ret = tree_delta_from_git_changes(changes, self.target.mapping, 
257
 
            (source_fileid_map, target_fileid_map),
258
 
            specific_file=specific_files, require_versioned=require_versioned)
259
 
        if want_unversioned:
260
 
            for e in self.target.extras():
261
 
                ret.unversioned.append((e, None, osutils.file_kind(self.target.abspath(e))))
262
 
        return ret
263
 
 
264
 
    def iter_changes(self, include_unchanged=False, specific_files=None,
265
 
        pb=None, extra_trees=[], require_versioned=True, want_unversioned=False):
266
 
        changes = self._index.changes_from_tree(
267
 
            self.source._repository._git.object_store, self.source.tree, 
268
 
            want_unchanged=include_unchanged)
269
 
        # FIXME: Handle want_unversioned
270
 
        return changes_from_git_changes(changes, self.target.mapping, 
271
 
            specific_file=specific_files)
272
 
 
273
 
tree.InterTree.register_optimiser(InterIndexGitTree)