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

  • Committer: Jelmer Vernooij
  • Date: 2018-11-16 18:15:40 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181116181540-7y2wbhqzjk067mqy
Fix repo acquisition.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/workingtree.py
 
1
# Copyright (C) 2008-2018 Jelmer Vernooij <jelmer@jelmer.uk>
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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
 
16
 
 
17
 
 
18
"""An adapter between a Git index and a Bazaar Working Tree"""
 
19
 
 
20
from __future__ import absolute_import
 
21
 
 
22
import itertools
 
23
from collections import defaultdict
 
24
import errno
 
25
from dulwich.ignore import (
 
26
    IgnoreFilterManager,
 
27
    )
 
28
from dulwich.file import GitFile, FileLocked
 
29
from dulwich.index import (
 
30
    Index,
 
31
    SHA1Writer,
 
32
    build_index_from_tree,
 
33
    index_entry_from_path,
 
34
    index_entry_from_stat,
 
35
    FLAG_STAGEMASK,
 
36
    read_submodule_head,
 
37
    validate_path,
 
38
    write_index_dict,
 
39
    )
 
40
from dulwich.object_store import (
 
41
    tree_lookup_path,
 
42
    )
 
43
from dulwich.objects import (
 
44
    S_ISGITLINK,
 
45
    )
 
46
import os
 
47
import posixpath
 
48
import stat
 
49
import sys
 
50
 
 
51
from .. import (
 
52
    conflicts as _mod_conflicts,
 
53
    errors,
 
54
    controldir as _mod_controldir,
 
55
    globbing,
 
56
    ignores,
 
57
    lock,
 
58
    merge,
 
59
    osutils,
 
60
    revision as _mod_revision,
 
61
    trace,
 
62
    transport as _mod_transport,
 
63
    tree,
 
64
    workingtree,
 
65
    )
 
66
from ..decorators import (
 
67
    only_raises,
 
68
    )
 
69
from ..mutabletree import (
 
70
    BadReferenceTarget,
 
71
    MutableTree,
 
72
    )
 
73
 
 
74
 
 
75
from .dir import (
 
76
    LocalGitDir,
 
77
    )
 
78
from .tree import (
 
79
    MutableGitIndexTree,
 
80
    )
 
81
from .mapping import (
 
82
    GitFileIdMap,
 
83
    mode_kind,
 
84
    )
 
85
 
 
86
IGNORE_FILENAME = ".gitignore"
 
87
 
 
88
 
 
89
class GitWorkingTree(MutableGitIndexTree, workingtree.WorkingTree):
 
90
    """A Git working tree."""
 
91
 
 
92
    def __init__(self, controldir, repo, branch):
 
93
        MutableGitIndexTree.__init__(self)
 
94
        basedir = controldir.root_transport.local_abspath('.')
 
95
        self.basedir = osutils.realpath(basedir)
 
96
        self.controldir = controldir
 
97
        self.repository = repo
 
98
        self.store = self.repository._git.object_store
 
99
        self.mapping = self.repository.get_mapping()
 
100
        self._branch = branch
 
101
        self._transport = self.repository._git._controltransport
 
102
        self._format = GitWorkingTreeFormat()
 
103
        self.index = None
 
104
        self._index_file = None
 
105
        self.views = self._make_views()
 
106
        self._rules_searcher = None
 
107
        self._detect_case_handling()
 
108
        self._reset_data()
 
109
 
 
110
    def supports_tree_reference(self):
 
111
        return True
 
112
 
 
113
    def supports_rename_tracking(self):
 
114
        return False
 
115
 
 
116
    def _read_index(self):
 
117
        self.index = Index(self.control_transport.local_abspath('index'))
 
118
        self._index_dirty = False
 
119
 
 
120
    def lock_read(self):
 
121
        """Lock the repository for read operations.
 
122
 
 
123
        :return: A breezy.lock.LogicalLockResult.
 
124
        """
 
125
        if not self._lock_mode:
 
126
            self._lock_mode = 'r'
 
127
            self._lock_count = 1
 
128
            self._read_index()
 
129
        else:
 
130
            self._lock_count += 1
 
131
        self.branch.lock_read()
 
132
        return lock.LogicalLockResult(self.unlock)
 
133
 
 
134
    def _lock_write_tree(self):
 
135
        if not self._lock_mode:
 
136
            self._lock_mode = 'w'
 
137
            self._lock_count = 1
 
138
            try:
 
139
                self._index_file = GitFile(
 
140
                    self.control_transport.local_abspath('index'), 'wb')
 
141
            except FileLocked:
 
142
                raise errors.LockContention('index')
 
143
            self._read_index()
 
144
        elif self._lock_mode == 'r':
 
145
            raise errors.ReadOnlyError(self)
 
146
        else:
 
147
            self._lock_count += 1
 
148
 
 
149
    def lock_tree_write(self):
 
150
        self.branch.lock_read()
 
151
        try:
 
152
            self._lock_write_tree()
 
153
            return lock.LogicalLockResult(self.unlock)
 
154
        except BaseException:
 
155
            self.branch.unlock()
 
156
            raise
 
157
 
 
158
    def lock_write(self, token=None):
 
159
        self.branch.lock_write()
 
160
        try:
 
161
            self._lock_write_tree()
 
162
            return lock.LogicalLockResult(self.unlock)
 
163
        except BaseException:
 
164
            self.branch.unlock()
 
165
            raise
 
166
 
 
167
    def is_locked(self):
 
168
        return self._lock_count >= 1
 
169
 
 
170
    def get_physical_lock_status(self):
 
171
        return False
 
172
 
 
173
    def break_lock(self):
 
174
        try:
 
175
            self.control_transport.delete('index.lock')
 
176
        except errors.NoSuchFile:
 
177
            pass
 
178
        self.branch.break_lock()
 
179
 
 
180
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
181
    def unlock(self):
 
182
        if not self._lock_count:
 
183
            return lock.cant_unlock_not_held(self)
 
184
        try:
 
185
            self._cleanup()
 
186
            self._lock_count -= 1
 
187
            if self._lock_count > 0:
 
188
                return
 
189
            if self._index_file is not None:
 
190
                if self._index_dirty:
 
191
                    self._flush(self._index_file)
 
192
                    self._index_file.close()
 
193
                else:
 
194
                    # Something else already triggered a write of the index
 
195
                    # file by calling .flush()
 
196
                    self._index_file.abort()
 
197
                self._index_file = None
 
198
            self._lock_mode = None
 
199
            self.index = None
 
200
        finally:
 
201
            self.branch.unlock()
 
202
 
 
203
    def _cleanup(self):
 
204
        pass
 
205
 
 
206
    def _detect_case_handling(self):
 
207
        try:
 
208
            self._transport.stat(".git/cOnFiG")
 
209
        except errors.NoSuchFile:
 
210
            self.case_sensitive = True
 
211
        else:
 
212
            self.case_sensitive = False
 
213
 
 
214
    def merge_modified(self):
 
215
        return {}
 
216
 
 
217
    def set_merge_modified(self, modified_hashes):
 
218
        raise errors.UnsupportedOperation(self.set_merge_modified, self)
 
219
 
 
220
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
221
        self.set_parent_ids([p for p, t in parents_list])
 
222
 
 
223
    def _set_merges_from_parent_ids(self, rhs_parent_ids):
 
224
        try:
 
225
            merges = [self.branch.lookup_bzr_revision_id(
 
226
                revid)[0] for revid in rhs_parent_ids]
 
227
        except errors.NoSuchRevision as e:
 
228
            raise errors.GhostRevisionUnusableHere(e.revision)
 
229
        if merges:
 
230
            self.control_transport.put_bytes(
 
231
                'MERGE_HEAD', b'\n'.join(merges),
 
232
                mode=self.controldir._get_file_mode())
 
233
        else:
 
234
            try:
 
235
                self.control_transport.delete('MERGE_HEAD')
 
236
            except errors.NoSuchFile:
 
237
                pass
 
238
 
 
239
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
240
        """Set the parent ids to revision_ids.
 
241
 
 
242
        See also set_parent_trees. This api will try to retrieve the tree data
 
243
        for each element of revision_ids from the trees repository. If you have
 
244
        tree data already available, it is more efficient to use
 
245
        set_parent_trees rather than set_parent_ids. set_parent_ids is however
 
246
        an easier API to use.
 
247
 
 
248
        :param revision_ids: The revision_ids to set as the parent ids of this
 
249
            working tree. Any of these may be ghosts.
 
250
        """
 
251
        with self.lock_tree_write():
 
252
            self._check_parents_for_ghosts(
 
253
                revision_ids, allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
254
            for revision_id in revision_ids:
 
255
                _mod_revision.check_not_reserved_id(revision_id)
 
256
 
 
257
            revision_ids = self._filter_parent_ids_by_ancestry(revision_ids)
 
258
 
 
259
            if len(revision_ids) > 0:
 
260
                self.set_last_revision(revision_ids[0])
 
261
            else:
 
262
                self.set_last_revision(_mod_revision.NULL_REVISION)
 
263
 
 
264
            self._set_merges_from_parent_ids(revision_ids[1:])
 
265
 
 
266
    def get_parent_ids(self):
 
267
        """See Tree.get_parent_ids.
 
268
 
 
269
        This implementation reads the pending merges list and last_revision
 
270
        value and uses that to decide what the parents list should be.
 
271
        """
 
272
        last_rev = _mod_revision.ensure_null(self._last_revision())
 
273
        if _mod_revision.NULL_REVISION == last_rev:
 
274
            parents = []
 
275
        else:
 
276
            parents = [last_rev]
 
277
        try:
 
278
            merges_bytes = self.control_transport.get_bytes('MERGE_HEAD')
 
279
        except errors.NoSuchFile:
 
280
            pass
 
281
        else:
 
282
            for l in osutils.split_lines(merges_bytes):
 
283
                revision_id = l.rstrip(b'\n')
 
284
                parents.append(
 
285
                    self.branch.lookup_foreign_revision_id(revision_id))
 
286
        return parents
 
287
 
 
288
    def check_state(self):
 
289
        """Check that the working state is/isn't valid."""
 
290
        pass
 
291
 
 
292
    def remove(self, files, verbose=False, to_file=None, keep_files=True,
 
293
               force=False):
 
294
        """Remove nominated files from the working tree metadata.
 
295
 
 
296
        :param files: File paths relative to the basedir.
 
297
        :param keep_files: If true, the files will also be kept.
 
298
        :param force: Delete files and directories, even if they are changed
 
299
            and even if the directories are not empty.
 
300
        """
 
301
        if not isinstance(files, list):
 
302
            files = [files]
 
303
 
 
304
        if to_file is None:
 
305
            to_file = sys.stdout
 
306
 
 
307
        def backup(file_to_backup):
 
308
            abs_path = self.abspath(file_to_backup)
 
309
            backup_name = self.controldir._available_backup_name(
 
310
                file_to_backup)
 
311
            osutils.rename(abs_path, self.abspath(backup_name))
 
312
            return "removed %s (but kept a copy: %s)" % (
 
313
                file_to_backup, backup_name)
 
314
 
 
315
        # Sort needed to first handle directory content before the directory
 
316
        files_to_backup = []
 
317
 
 
318
        all_files = set()
 
319
 
 
320
        def recurse_directory_to_add_files(directory):
 
321
            # Recurse directory and add all files
 
322
            # so we can check if they have changed.
 
323
            for parent_info, file_infos in self.walkdirs(directory):
 
324
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
 
325
                    # Is it versioned or ignored?
 
326
                    if self.is_versioned(relpath):
 
327
                        # Add nested content for deletion.
 
328
                        all_files.add(relpath)
 
329
                    else:
 
330
                        # Files which are not versioned
 
331
                        # should be treated as unknown.
 
332
                        files_to_backup.append(relpath)
 
333
 
 
334
        with self.lock_tree_write():
 
335
            for filepath in files:
 
336
                # Get file name into canonical form.
 
337
                abspath = self.abspath(filepath)
 
338
                filepath = self.relpath(abspath)
 
339
 
 
340
                if filepath:
 
341
                    all_files.add(filepath)
 
342
                    recurse_directory_to_add_files(filepath)
 
343
 
 
344
            files = list(all_files)
 
345
 
 
346
            if len(files) == 0:
 
347
                return  # nothing to do
 
348
 
 
349
            # Sort needed to first handle directory content before the
 
350
            # directory
 
351
            files.sort(reverse=True)
 
352
 
 
353
            # Bail out if we are going to delete files we shouldn't
 
354
            if not keep_files and not force:
 
355
                for (file_id, path, content_change, versioned, parent_id, name,
 
356
                     kind, executable) in self.iter_changes(
 
357
                         self.basis_tree(), include_unchanged=True,
 
358
                         require_versioned=False, want_unversioned=True,
 
359
                         specific_files=files):
 
360
                    if versioned[0] is False:
 
361
                        # The record is unknown or newly added
 
362
                        files_to_backup.append(path[1])
 
363
                        files_to_backup.extend(
 
364
                            osutils.parent_directories(path[1]))
 
365
                    elif (content_change and (kind[1] is not None)
 
366
                            and osutils.is_inside_any(files, path[1])):
 
367
                        # Versioned and changed, but not deleted, and still
 
368
                        # in one of the dirs to be deleted.
 
369
                        files_to_backup.append(path[1])
 
370
                        files_to_backup.extend(
 
371
                            osutils.parent_directories(path[1]))
 
372
 
 
373
            for f in files:
 
374
                if f == '':
 
375
                    continue
 
376
 
 
377
                try:
 
378
                    kind = self.kind(f)
 
379
                except errors.NoSuchFile:
 
380
                    kind = None
 
381
 
 
382
                abs_path = self.abspath(f)
 
383
                if verbose:
 
384
                    # having removed it, it must be either ignored or unknown
 
385
                    if self.is_ignored(f):
 
386
                        new_status = 'I'
 
387
                    else:
 
388
                        new_status = '?'
 
389
                    kind_ch = osutils.kind_marker(kind)
 
390
                    to_file.write(new_status + '       ' + f + kind_ch + '\n')
 
391
                if kind is None:
 
392
                    message = "%s does not exist" % (f, )
 
393
                else:
 
394
                    if not keep_files:
 
395
                        if f in files_to_backup and not force:
 
396
                            message = backup(f)
 
397
                        else:
 
398
                            if kind == 'directory':
 
399
                                osutils.rmtree(abs_path)
 
400
                            else:
 
401
                                osutils.delete_any(abs_path)
 
402
                            message = "deleted %s" % (f,)
 
403
                    else:
 
404
                        message = "removed %s" % (f,)
 
405
                self._unversion_path(f)
 
406
 
 
407
                # print only one message (if any) per file.
 
408
                if message is not None:
 
409
                    trace.note(message)
 
410
            self._versioned_dirs = None
 
411
 
 
412
    def smart_add(self, file_list, recurse=True, action=None, save=True):
 
413
        if not file_list:
 
414
            file_list = [u'.']
 
415
 
 
416
        # expand any symlinks in the directory part, while leaving the
 
417
        # filename alone
 
418
        # only expanding if symlinks are supported avoids windows path bugs
 
419
        if osutils.has_symlinks():
 
420
            file_list = list(map(osutils.normalizepath, file_list))
 
421
 
 
422
        conflicts_related = set()
 
423
        for c in self.conflicts():
 
424
            conflicts_related.update(c.associated_filenames())
 
425
 
 
426
        added = []
 
427
        ignored = {}
 
428
        user_dirs = []
 
429
 
 
430
        def call_action(filepath, kind):
 
431
            if filepath == '':
 
432
                return
 
433
            if action is not None:
 
434
                parent_path = posixpath.dirname(filepath)
 
435
                parent_id = self.path2id(parent_path)
 
436
                parent_ie = self._get_dir_ie(parent_path, parent_id)
 
437
                file_id = action(self, parent_ie, filepath, kind)
 
438
                if file_id is not None:
 
439
                    raise workingtree.SettingFileIdUnsupported()
 
440
 
 
441
        with self.lock_tree_write():
 
442
            for filepath in osutils.canonical_relpaths(
 
443
                    self.basedir, file_list):
 
444
                filepath, can_access = osutils.normalized_filename(filepath)
 
445
                if not can_access:
 
446
                    raise errors.InvalidNormalization(filepath)
 
447
 
 
448
                abspath = self.abspath(filepath)
 
449
                kind = osutils.file_kind(abspath)
 
450
                if kind in ("file", "symlink"):
 
451
                    (index, subpath) = self._lookup_index(
 
452
                        filepath.encode('utf-8'))
 
453
                    if subpath in index:
 
454
                        # Already present
 
455
                        continue
 
456
                    call_action(filepath, kind)
 
457
                    if save:
 
458
                        self._index_add_entry(filepath, kind)
 
459
                    added.append(filepath)
 
460
                elif kind == "directory":
 
461
                    (index, subpath) = self._lookup_index(
 
462
                        filepath.encode('utf-8'))
 
463
                    if subpath not in index:
 
464
                        call_action(filepath, kind)
 
465
                    if recurse:
 
466
                        user_dirs.append(filepath)
 
467
                else:
 
468
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
 
469
            for user_dir in user_dirs:
 
470
                abs_user_dir = self.abspath(user_dir)
 
471
                if user_dir != '':
 
472
                    try:
 
473
                        transport = _mod_transport.get_transport_from_path(
 
474
                            abs_user_dir)
 
475
                        _mod_controldir.ControlDirFormat.find_format(transport)
 
476
                        subtree = True
 
477
                    except errors.NotBranchError:
 
478
                        subtree = False
 
479
                    except errors.UnsupportedFormatError:
 
480
                        subtree = False
 
481
                else:
 
482
                    subtree = False
 
483
                if subtree:
 
484
                    trace.warning('skipping nested tree %r', abs_user_dir)
 
485
                    continue
 
486
 
 
487
                for name in os.listdir(abs_user_dir):
 
488
                    subp = os.path.join(user_dir, name)
 
489
                    if (self.is_control_filename(subp) or
 
490
                            self.mapping.is_special_file(subp)):
 
491
                        continue
 
492
                    ignore_glob = self.is_ignored(subp)
 
493
                    if ignore_glob is not None:
 
494
                        ignored.setdefault(ignore_glob, []).append(subp)
 
495
                        continue
 
496
                    abspath = self.abspath(subp)
 
497
                    kind = osutils.file_kind(abspath)
 
498
                    if kind == "directory":
 
499
                        user_dirs.append(subp)
 
500
                    else:
 
501
                        (index, subpath) = self._lookup_index(
 
502
                            subp.encode('utf-8'))
 
503
                        if subpath in index:
 
504
                            # Already present
 
505
                            continue
 
506
                        if subp in conflicts_related:
 
507
                            continue
 
508
                        call_action(subp, kind)
 
509
                        if save:
 
510
                            self._index_add_entry(subp, kind)
 
511
                        added.append(subp)
 
512
            return added, ignored
 
513
 
 
514
    def has_filename(self, filename):
 
515
        return osutils.lexists(self.abspath(filename))
 
516
 
 
517
    def _iter_files_recursive(self, from_dir=None, include_dirs=False):
 
518
        if from_dir is None:
 
519
            from_dir = u""
 
520
        encoded_from_dir = self.abspath(from_dir).encode(osutils._fs_enc)
 
521
        for (dirpath, dirnames, filenames) in os.walk(encoded_from_dir):
 
522
            dir_relpath = dirpath[len(self.basedir):].strip(b"/")
 
523
            if self.controldir.is_control_filename(
 
524
                    dir_relpath.decode(osutils._fs_enc)):
 
525
                continue
 
526
            for name in list(dirnames):
 
527
                if self.controldir.is_control_filename(
 
528
                        name.decode(osutils._fs_enc)):
 
529
                    dirnames.remove(name)
 
530
                    continue
 
531
                relpath = os.path.join(dir_relpath, name)
 
532
                if include_dirs:
 
533
                    try:
 
534
                        yield relpath.decode(osutils._fs_enc)
 
535
                    except UnicodeDecodeError:
 
536
                        raise errors.BadFilenameEncoding(
 
537
                            relpath, osutils._fs_enc)
 
538
                if not self._has_dir(relpath):
 
539
                    dirnames.remove(name)
 
540
            for name in filenames:
 
541
                if not self.mapping.is_special_file(name):
 
542
                    yp = os.path.join(dir_relpath, name)
 
543
                    try:
 
544
                        yield yp.decode(osutils._fs_enc)
 
545
                    except UnicodeDecodeError:
 
546
                        raise errors.BadFilenameEncoding(
 
547
                            yp, osutils._fs_enc)
 
548
 
 
549
    def extras(self):
 
550
        """Yield all unversioned files in this WorkingTree.
 
551
        """
 
552
        with self.lock_read():
 
553
            index_paths = set([p.decode('utf-8')
 
554
                               for p, i in self._recurse_index_entries()])
 
555
            all_paths = set(self._iter_files_recursive(include_dirs=True))
 
556
            for p in (all_paths - index_paths):
 
557
                if not self._has_dir(p.encode('utf-8')):
 
558
                    yield p
 
559
 
 
560
    def _gather_kinds(self, files, kinds):
 
561
        """See MutableTree._gather_kinds."""
 
562
        with self.lock_tree_write():
 
563
            for pos, f in enumerate(files):
 
564
                if kinds[pos] is None:
 
565
                    fullpath = osutils.normpath(self.abspath(f))
 
566
                    try:
 
567
                        kind = osutils.file_kind(fullpath)
 
568
                    except OSError as e:
 
569
                        if e.errno == errno.ENOENT:
 
570
                            raise errors.NoSuchFile(fullpath)
 
571
                    if (kind == 'directory' and f != '' and
 
572
                            os.path.exists(os.path.join(fullpath, '.git'))):
 
573
                        kind = 'tree-reference'
 
574
                    kinds[pos] = kind
 
575
 
 
576
    def flush(self):
 
577
        if self._lock_mode != 'w':
 
578
            raise errors.NotWriteLocked(self)
 
579
        # TODO(jelmer): This shouldn't be writing in-place, but index.lock is
 
580
        # already in use and GitFile doesn't allow overriding the lock file
 
581
        # name :(
 
582
        f = open(self.control_transport.local_abspath('index'), 'wb')
 
583
        # Note that _flush will close the file
 
584
        self._flush(f)
 
585
 
 
586
    def _flush(self, f):
 
587
        try:
 
588
            shaf = SHA1Writer(f)
 
589
            write_index_dict(shaf, self.index)
 
590
            shaf.close()
 
591
        except BaseException:
 
592
            f.abort()
 
593
            raise
 
594
        self._index_dirty = False
 
595
 
 
596
    def has_or_had_id(self, file_id):
 
597
        if self.has_id(file_id):
 
598
            return True
 
599
        if self.had_id(file_id):
 
600
            return True
 
601
        return False
 
602
 
 
603
    def had_id(self, file_id):
 
604
        path = self._basis_fileid_map.lookup_path(file_id)
 
605
        try:
 
606
            head = self.repository._git.head()
 
607
        except KeyError:
 
608
            # Assume no if basis is not accessible
 
609
            return False
 
610
        try:
 
611
            root_tree = self.store[head].tree
 
612
        except KeyError:
 
613
            return False
 
614
        try:
 
615
            tree_lookup_path(self.store.__getitem__,
 
616
                             root_tree, path.encode('utf-8'))
 
617
        except KeyError:
 
618
            return False
 
619
        else:
 
620
            return True
 
621
 
 
622
    def get_file_mtime(self, path, file_id=None):
 
623
        """See Tree.get_file_mtime."""
 
624
        try:
 
625
            return self._lstat(path).st_mtime
 
626
        except OSError as e:
 
627
            if e.errno == errno.ENOENT:
 
628
                raise errors.NoSuchFile(path)
 
629
            raise
 
630
 
 
631
    def is_ignored(self, filename):
 
632
        r"""Check whether the filename matches an ignore pattern.
 
633
 
 
634
        If the file is ignored, returns the pattern which caused it to
 
635
        be ignored, otherwise None.  So this can simply be used as a
 
636
        boolean if desired."""
 
637
        if getattr(self, '_global_ignoreglobster', None) is None:
 
638
            ignore_globs = set()
 
639
            ignore_globs.update(ignores.get_runtime_ignores())
 
640
            ignore_globs.update(ignores.get_user_ignores())
 
641
            self._global_ignoreglobster = globbing.ExceptionGlobster(
 
642
                ignore_globs)
 
643
        match = self._global_ignoreglobster.match(filename)
 
644
        if match is not None:
 
645
            return match
 
646
        try:
 
647
            if self.kind(filename) == 'directory':
 
648
                filename += '/'
 
649
        except errors.NoSuchFile:
 
650
            pass
 
651
        filename = filename.lstrip('/')
 
652
        ignore_manager = self._get_ignore_manager()
 
653
        ps = list(ignore_manager.find_matching(filename))
 
654
        if not ps:
 
655
            return None
 
656
        if not ps[-1].is_exclude:
 
657
            return None
 
658
        return bytes(ps[-1])
 
659
 
 
660
    def _get_ignore_manager(self):
 
661
        ignoremanager = getattr(self, '_ignoremanager', None)
 
662
        if ignoremanager is not None:
 
663
            return ignoremanager
 
664
 
 
665
        ignore_manager = IgnoreFilterManager.from_repo(self.repository._git)
 
666
        self._ignoremanager = ignore_manager
 
667
        return ignore_manager
 
668
 
 
669
    def _flush_ignore_list_cache(self):
 
670
        self._ignoremanager = None
 
671
 
 
672
    def set_last_revision(self, revid):
 
673
        if _mod_revision.is_null(revid):
 
674
            self.branch.set_last_revision_info(0, revid)
 
675
            return False
 
676
        _mod_revision.check_not_reserved_id(revid)
 
677
        try:
 
678
            self.branch.generate_revision_history(revid)
 
679
        except errors.NoSuchRevision:
 
680
            raise errors.GhostRevisionUnusableHere(revid)
 
681
 
 
682
    def _reset_data(self):
 
683
        try:
 
684
            head = self.repository._git.head()
 
685
        except KeyError:
 
686
            self._basis_fileid_map = GitFileIdMap({}, self.mapping)
 
687
        else:
 
688
            self._basis_fileid_map = self.mapping.get_fileid_map(
 
689
                self.store.__getitem__, self.store[head].tree)
 
690
        self._fileid_map = self._basis_fileid_map.copy()
 
691
 
 
692
    def get_file_verifier(self, path, file_id=None, stat_value=None):
 
693
        with self.lock_read():
 
694
            (index, subpath) = self._lookup_index(path.encode('utf-8'))
 
695
            try:
 
696
                return ("GIT", index[subpath].sha)
 
697
            except KeyError:
 
698
                if self._has_dir(path):
 
699
                    return ("GIT", None)
 
700
                raise errors.NoSuchFile(path)
 
701
 
 
702
    def get_file_sha1(self, path, file_id=None, stat_value=None):
 
703
        with self.lock_read():
 
704
            if not self.is_versioned(path):
 
705
                raise errors.NoSuchFile(path)
 
706
            abspath = self.abspath(path)
 
707
            try:
 
708
                return osutils.sha_file_by_name(abspath)
 
709
            except OSError as e:
 
710
                if e.errno in (errno.EISDIR, errno.ENOENT):
 
711
                    return None
 
712
                raise
 
713
 
 
714
    def revision_tree(self, revid):
 
715
        return self.repository.revision_tree(revid)
 
716
 
 
717
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
 
718
        mode = stat_result.st_mode
 
719
        return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
720
 
 
721
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
 
722
        return self.basis_tree().is_executable(path)
 
723
 
 
724
    def stored_kind(self, path, file_id=None):
 
725
        with self.lock_read():
 
726
            encoded_path = path.encode('utf-8')
 
727
            (index, subpath) = self._lookup_index(encoded_path)
 
728
            try:
 
729
                return mode_kind(index[subpath].mode)
 
730
            except KeyError:
 
731
                # Maybe it's a directory?
 
732
                if self._has_dir(encoded_path):
 
733
                    return "directory"
 
734
                raise errors.NoSuchFile(path)
 
735
 
 
736
    def _lstat(self, path):
 
737
        return os.lstat(self.abspath(path))
 
738
 
 
739
    def _live_entry(self, path):
 
740
        encoded_path = self.abspath(path.decode('utf-8')).encode(
 
741
            osutils._fs_enc)
 
742
        return index_entry_from_path(encoded_path)
 
743
 
 
744
    def is_executable(self, path, file_id=None):
 
745
        with self.lock_read():
 
746
            if getattr(self, "_supports_executable",
 
747
                       osutils.supports_executable)():
 
748
                mode = self._lstat(path).st_mode
 
749
            else:
 
750
                (index, subpath) = self._lookup_index(path.encode('utf-8'))
 
751
                try:
 
752
                    mode = index[subpath].mode
 
753
                except KeyError:
 
754
                    mode = 0
 
755
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
756
 
 
757
    def _is_executable_from_path_and_stat(self, path, stat_result):
 
758
        if getattr(self, "_supports_executable",
 
759
                   osutils.supports_executable)():
 
760
            return self._is_executable_from_path_and_stat_from_stat(
 
761
                path, stat_result)
 
762
        else:
 
763
            return self._is_executable_from_path_and_stat_from_basis(
 
764
                path, stat_result)
 
765
 
 
766
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
767
        if from_dir is None:
 
768
            from_dir = u""
 
769
        dir_ids = {}
 
770
        fk_entries = {'directory': tree.TreeDirectory,
 
771
                      'file': tree.TreeFile,
 
772
                      'symlink': tree.TreeLink,
 
773
                      'tree-reference': tree.TreeReference}
 
774
        with self.lock_read():
 
775
            root_ie = self._get_dir_ie(u"", None)
 
776
            if include_root and not from_dir:
 
777
                yield "", "V", root_ie.kind, root_ie.file_id, root_ie
 
778
            dir_ids[u""] = root_ie.file_id
 
779
            if recursive:
 
780
                path_iterator = sorted(
 
781
                    self._iter_files_recursive(from_dir, include_dirs=True))
 
782
            else:
 
783
                encoded_from_dir = self.abspath(from_dir).encode(
 
784
                    osutils._fs_enc)
 
785
                path_iterator = sorted(
 
786
                    [os.path.join(from_dir, name.decode(osutils._fs_enc))
 
787
                     for name in os.listdir(encoded_from_dir)
 
788
                     if not self.controldir.is_control_filename(
 
789
                         name.decode(osutils._fs_enc)) and
 
790
                     not self.mapping.is_special_file(
 
791
                         name.decode(osutils._fs_enc))])
 
792
            for path in path_iterator:
 
793
                try:
 
794
                    encoded_path = path.encode("utf-8")
 
795
                except UnicodeEncodeError:
 
796
                    raise errors.BadFilenameEncoding(
 
797
                        path, osutils._fs_enc)
 
798
                (index, index_path) = self._lookup_index(encoded_path)
 
799
                try:
 
800
                    value = index[index_path]
 
801
                except KeyError:
 
802
                    value = None
 
803
                kind = self.kind(path)
 
804
                parent, name = posixpath.split(path)
 
805
                for dir_path, dir_ie in self._add_missing_parent_ids(
 
806
                        parent, dir_ids):
 
807
                    pass
 
808
                if kind in ('directory', 'tree-reference'):
 
809
                    if path != from_dir:
 
810
                        if self._has_dir(encoded_path):
 
811
                            ie = self._get_dir_ie(path, self.path2id(path))
 
812
                            status = "V"
 
813
                            file_id = ie.file_id
 
814
                        elif self.is_ignored(path):
 
815
                            status = "I"
 
816
                            ie = fk_entries[kind]()
 
817
                            file_id = None
 
818
                        else:
 
819
                            status = "?"
 
820
                            ie = fk_entries[kind]()
 
821
                            file_id = None
 
822
                        yield (
 
823
                            posixpath.relpath(path, from_dir), status, kind,
 
824
                            file_id, ie)
 
825
                    continue
 
826
                if value is not None:
 
827
                    ie = self._get_file_ie(name, path, value, dir_ids[parent])
 
828
                    yield (posixpath.relpath(path, from_dir), "V", ie.kind,
 
829
                           ie.file_id, ie)
 
830
                else:
 
831
                    ie = fk_entries[kind]()
 
832
                    yield (posixpath.relpath(path, from_dir), ("I" if
 
833
                                                               self.is_ignored(path) else "?"), kind, None, ie)
 
834
 
 
835
    def all_file_ids(self):
 
836
        with self.lock_read():
 
837
            ids = {u"": self.path2id("")}
 
838
            for path in self.index:
 
839
                if self.mapping.is_special_file(path):
 
840
                    continue
 
841
                path = path.decode("utf-8")
 
842
                parent = posixpath.dirname(path).strip("/")
 
843
                for e in self._add_missing_parent_ids(parent, ids):
 
844
                    pass
 
845
                ids[path] = self.path2id(path)
 
846
            return set(ids.values())
 
847
 
 
848
    def all_versioned_paths(self):
 
849
        with self.lock_read():
 
850
            paths = {u""}
 
851
            for path in self.index:
 
852
                if self.mapping.is_special_file(path):
 
853
                    continue
 
854
                path = path.decode("utf-8")
 
855
                paths.add(path)
 
856
                while path != "":
 
857
                    path = posixpath.dirname(path).strip("/")
 
858
                    if path in paths:
 
859
                        break
 
860
                    paths.add(path)
 
861
            return paths
 
862
 
 
863
    def iter_child_entries(self, path, file_id=None):
 
864
        with self.lock_read():
 
865
            parent_id = self.path2id(path)
 
866
            found_any = False
 
867
            for item_path, value in self.index.iteritems():
 
868
                decoded_item_path = item_path.decode('utf-8')
 
869
                if self.mapping.is_special_file(item_path):
 
870
                    continue
 
871
                if not osutils.is_inside(path, decoded_item_path):
 
872
                    continue
 
873
                found_any = True
 
874
                subpath = posixpath.relpath(decoded_item_path, path)
 
875
                if '/' in subpath:
 
876
                    dirname = subpath.split('/', 1)[0]
 
877
                    file_ie = self._get_dir_ie(
 
878
                        posixpath.join(path, dirname), parent_id)
 
879
                else:
 
880
                    (unused_parent, name) = posixpath.split(decoded_item_path)
 
881
                    file_ie = self._get_file_ie(
 
882
                        name, decoded_item_path, value, parent_id)
 
883
                yield file_ie
 
884
            if not found_any and path != u'':
 
885
                raise errors.NoSuchFile(path)
 
886
 
 
887
    def conflicts(self):
 
888
        with self.lock_read():
 
889
            conflicts = _mod_conflicts.ConflictList()
 
890
            for item_path, value in self.index.iteritems():
 
891
                if value.flags & FLAG_STAGEMASK:
 
892
                    conflicts.append(_mod_conflicts.TextConflict(
 
893
                        item_path.decode('utf-8')))
 
894
            return conflicts
 
895
 
 
896
    def set_conflicts(self, conflicts):
 
897
        by_path = set()
 
898
        for conflict in conflicts:
 
899
            if conflict.typestring in ('text conflict', 'contents conflict'):
 
900
                by_path.add(conflict.path.encode('utf-8'))
 
901
            else:
 
902
                raise errors.UnsupportedOperation(self.set_conflicts, self)
 
903
        with self.lock_tree_write():
 
904
            for path in self.index:
 
905
                self._set_conflicted(path, path in by_path)
 
906
 
 
907
    def _set_conflicted(self, path, conflicted):
 
908
        trace.mutter('change conflict: %r -> %r', path, conflicted)
 
909
        value = self.index[path]
 
910
        self._index_dirty = True
 
911
        if conflicted:
 
912
            self.index[path] = (value[:9] + (value[9] | FLAG_STAGEMASK, ))
 
913
        else:
 
914
            self.index[path] = (value[:9] + (value[9] & ~ FLAG_STAGEMASK, ))
 
915
 
 
916
    def add_conflicts(self, new_conflicts):
 
917
        with self.lock_tree_write():
 
918
            for conflict in new_conflicts:
 
919
                if conflict.typestring in ('text conflict',
 
920
                                           'contents conflict'):
 
921
                    try:
 
922
                        self._set_conflicted(
 
923
                            conflict.path.encode('utf-8'), True)
 
924
                    except KeyError:
 
925
                        raise errors.UnsupportedOperation(
 
926
                            self.add_conflicts, self)
 
927
                else:
 
928
                    raise errors.UnsupportedOperation(self.add_conflicts, self)
 
929
 
 
930
    def walkdirs(self, prefix=""):
 
931
        """Walk the directories of this tree.
 
932
 
 
933
        returns a generator which yields items in the form:
 
934
                ((curren_directory_path, fileid),
 
935
                 [(file1_path, file1_name, file1_kind, (lstat), file1_id,
 
936
                   file1_kind), ... ])
 
937
 
 
938
        This API returns a generator, which is only valid during the current
 
939
        tree transaction - within a single lock_read or lock_write duration.
 
940
 
 
941
        If the tree is not locked, it may cause an error to be raised,
 
942
        depending on the tree implementation.
 
943
        """
 
944
        from bisect import bisect_left
 
945
        import operator
 
946
        disk_top = self.abspath(prefix)
 
947
        if disk_top.endswith('/'):
 
948
            disk_top = disk_top[:-1]
 
949
        top_strip_len = len(disk_top) + 1
 
950
        inventory_iterator = self._walkdirs(prefix)
 
951
        disk_iterator = osutils.walkdirs(disk_top, prefix)
 
952
        try:
 
953
            current_disk = next(disk_iterator)
 
954
            disk_finished = False
 
955
        except OSError as e:
 
956
            if not (e.errno == errno.ENOENT
 
957
                    or (sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
 
958
                raise
 
959
            current_disk = None
 
960
            disk_finished = True
 
961
        try:
 
962
            current_inv = next(inventory_iterator)
 
963
            inv_finished = False
 
964
        except StopIteration:
 
965
            current_inv = None
 
966
            inv_finished = True
 
967
        while not inv_finished or not disk_finished:
 
968
            if current_disk:
 
969
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
 
970
                    cur_disk_dir_content) = current_disk
 
971
            else:
 
972
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
 
973
                    cur_disk_dir_content) = ((None, None), None)
 
974
            if not disk_finished:
 
975
                # strip out .bzr dirs
 
976
                if (cur_disk_dir_path_from_top[top_strip_len:] == ''
 
977
                        and len(cur_disk_dir_content) > 0):
 
978
                    # osutils.walkdirs can be made nicer -
 
979
                    # yield the path-from-prefix rather than the pathjoined
 
980
                    # value.
 
981
                    bzrdir_loc = bisect_left(cur_disk_dir_content,
 
982
                                             ('.git', '.git'))
 
983
                    if (bzrdir_loc < len(cur_disk_dir_content) and
 
984
                        self.controldir.is_control_filename(
 
985
                            cur_disk_dir_content[bzrdir_loc][0])):
 
986
                        # we dont yield the contents of, or, .bzr itself.
 
987
                        del cur_disk_dir_content[bzrdir_loc]
 
988
            if inv_finished:
 
989
                # everything is unknown
 
990
                direction = 1
 
991
            elif disk_finished:
 
992
                # everything is missing
 
993
                direction = -1
 
994
            else:
 
995
                direction = ((current_inv[0][0] > cur_disk_dir_relpath)
 
996
                             - (current_inv[0][0] < cur_disk_dir_relpath))
 
997
            if direction > 0:
 
998
                # disk is before inventory - unknown
 
999
                dirblock = [(relpath, basename, kind, stat, None, None) for
 
1000
                            relpath, basename, kind, stat, top_path in
 
1001
                            cur_disk_dir_content]
 
1002
                yield (cur_disk_dir_relpath, None), dirblock
 
1003
                try:
 
1004
                    current_disk = next(disk_iterator)
 
1005
                except StopIteration:
 
1006
                    disk_finished = True
 
1007
            elif direction < 0:
 
1008
                # inventory is before disk - missing.
 
1009
                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
 
1010
                            for relpath, basename, dkind, stat, fileid, kind in
 
1011
                            current_inv[1]]
 
1012
                yield (current_inv[0][0], current_inv[0][1]), dirblock
 
1013
                try:
 
1014
                    current_inv = next(inventory_iterator)
 
1015
                except StopIteration:
 
1016
                    inv_finished = True
 
1017
            else:
 
1018
                # versioned present directory
 
1019
                # merge the inventory and disk data together
 
1020
                dirblock = []
 
1021
                for relpath, subiterator in itertools.groupby(sorted(
 
1022
                        current_inv[1] + cur_disk_dir_content,
 
1023
                        key=operator.itemgetter(0)), operator.itemgetter(1)):
 
1024
                    path_elements = list(subiterator)
 
1025
                    if len(path_elements) == 2:
 
1026
                        inv_row, disk_row = path_elements
 
1027
                        # versioned, present file
 
1028
                        dirblock.append((inv_row[0],
 
1029
                                         inv_row[1], disk_row[2],
 
1030
                                         disk_row[3], inv_row[4],
 
1031
                                         inv_row[5]))
 
1032
                    elif len(path_elements[0]) == 5:
 
1033
                        # unknown disk file
 
1034
                        dirblock.append(
 
1035
                            (path_elements[0][0], path_elements[0][1],
 
1036
                                path_elements[0][2], path_elements[0][3],
 
1037
                                None, None))
 
1038
                    elif len(path_elements[0]) == 6:
 
1039
                        # versioned, absent file.
 
1040
                        dirblock.append(
 
1041
                            (path_elements[0][0], path_elements[0][1],
 
1042
                                'unknown', None, path_elements[0][4],
 
1043
                                path_elements[0][5]))
 
1044
                    else:
 
1045
                        raise NotImplementedError('unreachable code')
 
1046
                yield current_inv[0], dirblock
 
1047
                try:
 
1048
                    current_inv = next(inventory_iterator)
 
1049
                except StopIteration:
 
1050
                    inv_finished = True
 
1051
                try:
 
1052
                    current_disk = next(disk_iterator)
 
1053
                except StopIteration:
 
1054
                    disk_finished = True
 
1055
 
 
1056
    def _walkdirs(self, prefix=u""):
 
1057
        if prefix != u"":
 
1058
            prefix += u"/"
 
1059
        prefix = prefix.encode('utf-8')
 
1060
        per_dir = defaultdict(set)
 
1061
        if prefix == b"":
 
1062
            per_dir[(u'', self.get_root_id())] = set()
 
1063
 
 
1064
        def add_entry(path, kind):
 
1065
            if path == b'' or not path.startswith(prefix):
 
1066
                return
 
1067
            (dirname, child_name) = posixpath.split(path)
 
1068
            add_entry(dirname, 'directory')
 
1069
            dirname = dirname.decode("utf-8")
 
1070
            dir_file_id = self.path2id(dirname)
 
1071
            if not isinstance(value, tuple) or len(value) != 10:
 
1072
                raise ValueError(value)
 
1073
            per_dir[(dirname, dir_file_id)].add(
 
1074
                (path.decode("utf-8"), child_name.decode("utf-8"),
 
1075
                 kind, None,
 
1076
                 self.path2id(path.decode("utf-8")),
 
1077
                 kind))
 
1078
        with self.lock_read():
 
1079
            for path, value in self.index.iteritems():
 
1080
                if self.mapping.is_special_file(path):
 
1081
                    continue
 
1082
                if not path.startswith(prefix):
 
1083
                    continue
 
1084
                add_entry(path, mode_kind(value.mode))
 
1085
        return ((k, sorted(v)) for (k, v) in sorted(per_dir.items()))
 
1086
 
 
1087
    def get_shelf_manager(self):
 
1088
        raise workingtree.ShelvingUnsupported()
 
1089
 
 
1090
    def store_uncommitted(self):
 
1091
        raise errors.StoringUncommittedNotSupported(self)
 
1092
 
 
1093
    def apply_inventory_delta(self, changes):
 
1094
        for (old_path, new_path, file_id, ie) in changes:
 
1095
            if old_path is not None:
 
1096
                (index, old_subpath) = self._lookup_index(
 
1097
                    old_path.encode('utf-8'))
 
1098
                try:
 
1099
                    self._index_del_entry(index, old_subpath)
 
1100
                except KeyError:
 
1101
                    pass
 
1102
                else:
 
1103
                    self._versioned_dirs = None
 
1104
            if new_path is not None and ie.kind != 'directory':
 
1105
                if ie.kind == 'tree-reference':
 
1106
                    self._index_add_entry(
 
1107
                        new_path, ie.kind,
 
1108
                        reference_revision=ie.reference_revision)
 
1109
                else:
 
1110
                    self._index_add_entry(new_path, ie.kind)
 
1111
        self.flush()
 
1112
 
 
1113
    def annotate_iter(self, path, file_id=None,
 
1114
                      default_revision=_mod_revision.CURRENT_REVISION):
 
1115
        """See Tree.annotate_iter
 
1116
 
 
1117
        This implementation will use the basis tree implementation if possible.
 
1118
        Lines not in the basis are attributed to CURRENT_REVISION
 
1119
 
 
1120
        If there are pending merges, lines added by those merges will be
 
1121
        incorrectly attributed to CURRENT_REVISION (but after committing, the
 
1122
        attribution will be correct).
 
1123
        """
 
1124
        with self.lock_read():
 
1125
            maybe_file_parent_keys = []
 
1126
            for parent_id in self.get_parent_ids():
 
1127
                try:
 
1128
                    parent_tree = self.revision_tree(parent_id)
 
1129
                except errors.NoSuchRevisionInTree:
 
1130
                    parent_tree = self.branch.repository.revision_tree(
 
1131
                        parent_id)
 
1132
                with parent_tree.lock_read():
 
1133
                    # TODO(jelmer): Use rename/copy tracker to find path name
 
1134
                    # in parent
 
1135
                    parent_path = path
 
1136
                    try:
 
1137
                        kind = parent_tree.kind(parent_path)
 
1138
                    except errors.NoSuchFile:
 
1139
                        continue
 
1140
                    if kind != 'file':
 
1141
                        # Note: this is slightly unnecessary, because symlinks
 
1142
                        # and directories have a "text" which is the empty
 
1143
                        # text, and we know that won't mess up annotations. But
 
1144
                        # it seems cleaner
 
1145
                        continue
 
1146
                    parent_text_key = (
 
1147
                        parent_path,
 
1148
                        parent_tree.get_file_revision(parent_path))
 
1149
                    if parent_text_key not in maybe_file_parent_keys:
 
1150
                        maybe_file_parent_keys.append(parent_text_key)
 
1151
            # Now we have the parents of this content
 
1152
            from breezy.annotate import Annotator
 
1153
            from .annotate import AnnotateProvider
 
1154
            annotate_provider = AnnotateProvider(
 
1155
                self.branch.repository._file_change_scanner)
 
1156
            annotator = Annotator(annotate_provider)
 
1157
 
 
1158
            from breezy.graph import Graph
 
1159
            graph = Graph(annotate_provider)
 
1160
            heads = graph.heads(maybe_file_parent_keys)
 
1161
            file_parent_keys = []
 
1162
            for key in maybe_file_parent_keys:
 
1163
                if key in heads:
 
1164
                    file_parent_keys.append(key)
 
1165
 
 
1166
            text = self.get_file_text(path)
 
1167
            this_key = (path, default_revision)
 
1168
            annotator.add_special_text(this_key, file_parent_keys, text)
 
1169
            annotations = [(key[-1], line)
 
1170
                           for key, line in annotator.annotate_flat(this_key)]
 
1171
            return annotations
 
1172
 
 
1173
    def _rename_one(self, from_rel, to_rel):
 
1174
        os.rename(self.abspath(from_rel), self.abspath(to_rel))
 
1175
 
 
1176
    def _build_checkout_with_index(self):
 
1177
        build_index_from_tree(
 
1178
            self.user_transport.local_abspath('.'),
 
1179
            self.control_transport.local_abspath("index"),
 
1180
            self.store,
 
1181
            None
 
1182
            if self.branch.head is None
 
1183
            else self.store[self.branch.head].tree)
 
1184
 
 
1185
    def reset_state(self, revision_ids=None):
 
1186
        """Reset the state of the working tree.
 
1187
 
 
1188
        This does a hard-reset to a last-known-good state. This is a way to
 
1189
        fix if something got corrupted (like the .git/index file)
 
1190
        """
 
1191
        with self.lock_tree_write():
 
1192
            if revision_ids is not None:
 
1193
                self.set_parent_ids(revision_ids)
 
1194
            self.index.clear()
 
1195
            self._index_dirty = True
 
1196
            if self.branch.head is not None:
 
1197
                for entry in self.store.iter_tree_contents(
 
1198
                        self.store[self.branch.head].tree):
 
1199
                    if not validate_path(entry.path):
 
1200
                        continue
 
1201
 
 
1202
                    if S_ISGITLINK(entry.mode):
 
1203
                        pass  # TODO(jelmer): record and return submodule paths
 
1204
                    else:
 
1205
                        # Let's at least try to use the working tree file:
 
1206
                        try:
 
1207
                            st = self._lstat(self.abspath(
 
1208
                                entry.path.decode('utf-8')))
 
1209
                        except OSError:
 
1210
                            # But if it doesn't exist, we'll make something up.
 
1211
                            obj = self.store[entry.sha]
 
1212
                            st = os.stat_result((entry.mode, 0, 0, 0,
 
1213
                                                 0, 0, len(
 
1214
                                                     obj.as_raw_string()), 0,
 
1215
                                                 0, 0))
 
1216
                    (index, subpath) = self._lookup_index(entry.path)
 
1217
                    index[subpath] = index_entry_from_stat(st, entry.sha, 0)
 
1218
 
 
1219
    def pull(self, source, overwrite=False, stop_revision=None,
 
1220
             change_reporter=None, possible_transports=None, local=False,
 
1221
             show_base=False):
 
1222
        with self.lock_write(), source.lock_read():
 
1223
            old_revision = self.branch.last_revision()
 
1224
            basis_tree = self.basis_tree()
 
1225
            count = self.branch.pull(source, overwrite, stop_revision,
 
1226
                                     possible_transports=possible_transports,
 
1227
                                     local=local)
 
1228
            new_revision = self.branch.last_revision()
 
1229
            if new_revision != old_revision:
 
1230
                with basis_tree.lock_read():
 
1231
                    new_basis_tree = self.branch.basis_tree()
 
1232
                    merge.merge_inner(
 
1233
                        self.branch,
 
1234
                        new_basis_tree,
 
1235
                        basis_tree,
 
1236
                        this_tree=self,
 
1237
                        change_reporter=change_reporter,
 
1238
                        show_base=show_base)
 
1239
            return count
 
1240
 
 
1241
    def add_reference(self, sub_tree):
 
1242
        """Add a TreeReference to the tree, pointing at sub_tree.
 
1243
 
 
1244
        :param sub_tree: subtree to add.
 
1245
        """
 
1246
        with self.lock_tree_write():
 
1247
            try:
 
1248
                sub_tree_path = self.relpath(sub_tree.basedir)
 
1249
            except errors.PathNotChild:
 
1250
                raise BadReferenceTarget(
 
1251
                    self, sub_tree, 'Target not inside tree.')
 
1252
 
 
1253
            self._add([sub_tree_path], [None], ['tree-reference'])
 
1254
 
 
1255
    def _read_submodule_head(self, path):
 
1256
        return read_submodule_head(self.abspath(path))
 
1257
 
 
1258
    def get_reference_revision(self, path, file_id=None):
 
1259
        hexsha = self._read_submodule_head(path)
 
1260
        if hexsha is None:
 
1261
            return _mod_revision.NULL_REVISION
 
1262
        return self.branch.lookup_foreign_revision_id(hexsha)
 
1263
 
 
1264
    def get_nested_tree(self, path, file_id=None):
 
1265
        return workingtree.WorkingTree.open(self.abspath(path))
 
1266
 
 
1267
    def _directory_is_tree_reference(self, relpath):
 
1268
        # as a special case, if a directory contains control files then
 
1269
        # it's a tree reference, except that the root of the tree is not
 
1270
        return relpath and osutils.lexists(self.abspath(relpath) + u"/.git")
 
1271
 
 
1272
    def extract(self, sub_path, file_id=None, format=None):
 
1273
        """Extract a subtree from this tree.
 
1274
 
 
1275
        A new branch will be created, relative to the path for this tree.
 
1276
        """
 
1277
        def mkdirs(path):
 
1278
            segments = osutils.splitpath(path)
 
1279
            transport = self.branch.controldir.root_transport
 
1280
            for name in segments:
 
1281
                transport = transport.clone(name)
 
1282
                transport.ensure_base()
 
1283
            return transport
 
1284
 
 
1285
        with self.lock_tree_write():
 
1286
            self.flush()
 
1287
            branch_transport = mkdirs(sub_path)
 
1288
            if format is None:
 
1289
                format = self.controldir.cloning_metadir()
 
1290
            branch_transport.ensure_base()
 
1291
            branch_bzrdir = format.initialize_on_transport(branch_transport)
 
1292
            try:
 
1293
                repo = branch_bzrdir.find_repository()
 
1294
            except errors.NoRepositoryPresent:
 
1295
                repo = branch_bzrdir.create_repository()
 
1296
            if not repo.supports_rich_root():
 
1297
                raise errors.RootNotRich()
 
1298
            new_branch = branch_bzrdir.create_branch()
 
1299
            new_branch.pull(self.branch)
 
1300
            for parent_id in self.get_parent_ids():
 
1301
                new_branch.fetch(self.branch, parent_id)
 
1302
            tree_transport = self.controldir.root_transport.clone(sub_path)
 
1303
            if tree_transport.base != branch_transport.base:
 
1304
                tree_bzrdir = format.initialize_on_transport(tree_transport)
 
1305
                tree_bzrdir.set_branch_reference(new_branch)
 
1306
            else:
 
1307
                tree_bzrdir = branch_bzrdir
 
1308
            wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
 
1309
            wt.set_parent_ids(self.get_parent_ids())
 
1310
            return wt
 
1311
 
 
1312
    def _get_check_refs(self):
 
1313
        """Return the references needed to perform a check of this tree.
 
1314
 
 
1315
        The default implementation returns no refs, and is only suitable for
 
1316
        trees that have no local caching and can commit on ghosts at any time.
 
1317
 
 
1318
        :seealso: breezy.check for details about check_refs.
 
1319
        """
 
1320
        return []
 
1321
 
 
1322
    def copy_content_into(self, tree, revision_id=None):
 
1323
        """Copy the current content and user files of this tree into tree."""
 
1324
        with self.lock_read():
 
1325
            if revision_id is None:
 
1326
                merge.transform_tree(tree, self)
 
1327
            else:
 
1328
                # TODO now merge from tree.last_revision to revision (to
 
1329
                # preserve user local changes)
 
1330
                try:
 
1331
                    other_tree = self.revision_tree(revision_id)
 
1332
                except errors.NoSuchRevision:
 
1333
                    other_tree = self.branch.repository.revision_tree(
 
1334
                        revision_id)
 
1335
 
 
1336
                merge.transform_tree(tree, other_tree)
 
1337
                if revision_id == _mod_revision.NULL_REVISION:
 
1338
                    new_parents = []
 
1339
                else:
 
1340
                    new_parents = [revision_id]
 
1341
                tree.set_parent_ids(new_parents)
 
1342
 
 
1343
 
 
1344
class GitWorkingTreeFormat(workingtree.WorkingTreeFormat):
 
1345
 
 
1346
    _tree_class = GitWorkingTree
 
1347
 
 
1348
    supports_versioned_directories = False
 
1349
 
 
1350
    supports_setting_file_ids = False
 
1351
 
 
1352
    supports_store_uncommitted = False
 
1353
 
 
1354
    supports_leftmost_parent_id_as_ghost = False
 
1355
 
 
1356
    supports_righthand_parent_id_as_ghost = False
 
1357
 
 
1358
    requires_normalized_unicode_filenames = True
 
1359
 
 
1360
    supports_merge_modified = False
 
1361
 
 
1362
    @property
 
1363
    def _matchingcontroldir(self):
 
1364
        from .dir import LocalGitControlDirFormat
 
1365
        return LocalGitControlDirFormat()
 
1366
 
 
1367
    def get_format_description(self):
 
1368
        return "Git Working Tree"
 
1369
 
 
1370
    def initialize(self, a_controldir, revision_id=None, from_branch=None,
 
1371
                   accelerator_tree=None, hardlink=False):
 
1372
        """See WorkingTreeFormat.initialize()."""
 
1373
        if not isinstance(a_controldir, LocalGitDir):
 
1374
            raise errors.IncompatibleFormat(self, a_controldir)
 
1375
        branch = a_controldir.open_branch(nascent_ok=True)
 
1376
        if revision_id is not None:
 
1377
            branch.set_last_revision(revision_id)
 
1378
        wt = GitWorkingTree(
 
1379
            a_controldir, a_controldir.open_repository(), branch)
 
1380
        for hook in MutableTree.hooks['post_build_tree']:
 
1381
            hook(wt)
 
1382
        return wt