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

  • Committer: Aaron Bentley
  • Date: 2005-10-01 06:48:01 UTC
  • mto: (1185.12.13)
  • mto: This revision was merged to the branch mainline in revision 1419.
  • Revision ID: aaron.bentley@utoronto.ca-20051001064801-7400c2ed0fe26080
Made iter_conflicts a WorkingTree method

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
# TODO: Don't allow WorkingTrees to be constructed for remote branches.
 
18
 
 
19
# FIXME: I don't know if writing out the cache from the destructor is really a
 
20
# good idea, because destructors are considered poor taste in Python, and
 
21
# it's not predictable when it will be written out.
 
22
 
 
23
import os
 
24
import fnmatch
 
25
        
 
26
import bzrlib.tree
 
27
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath
 
28
from bzrlib.errors import BzrCheckError
 
29
from bzrlib.trace import mutter
 
30
 
 
31
class WorkingTree(bzrlib.tree.Tree):
 
32
    """Working copy tree.
 
33
 
 
34
    The inventory is held in the `Branch` working-inventory, and the
 
35
    files are in a directory on disk.
 
36
 
 
37
    It is possible for a `WorkingTree` to have a filename which is
 
38
    not listed in the Inventory and vice versa.
 
39
    """
 
40
    def __init__(self, basedir, inv):
 
41
        from bzrlib.hashcache import HashCache
 
42
        from bzrlib.trace import note, mutter
 
43
 
 
44
        self._inventory = inv
 
45
        self.basedir = basedir
 
46
        self.path2id = inv.path2id
 
47
 
 
48
        # update the whole cache up front and write to disk if anything changed;
 
49
        # in the future we might want to do this more selectively
 
50
        hc = self._hashcache = HashCache(basedir)
 
51
        hc.read()
 
52
        hc.scan()
 
53
 
 
54
        if hc.needs_write:
 
55
            mutter("write hc")
 
56
            hc.write()
 
57
            
 
58
            
 
59
    def __del__(self):
 
60
        if self._hashcache.needs_write:
 
61
            self._hashcache.write()
 
62
 
 
63
 
 
64
    def __iter__(self):
 
65
        """Iterate through file_ids for this tree.
 
66
 
 
67
        file_ids are in a WorkingTree if they are in the working inventory
 
68
        and the working file exists.
 
69
        """
 
70
        inv = self._inventory
 
71
        for path, ie in inv.iter_entries():
 
72
            if os.path.exists(self.abspath(path)):
 
73
                yield ie.file_id
 
74
 
 
75
 
 
76
    def __repr__(self):
 
77
        return "<%s of %s>" % (self.__class__.__name__,
 
78
                               getattr(self, 'basedir', None))
 
79
 
 
80
 
 
81
 
 
82
    def abspath(self, filename):
 
83
        return os.path.join(self.basedir, filename)
 
84
 
 
85
    def has_filename(self, filename):
 
86
        return os.path.exists(self.abspath(filename))
 
87
 
 
88
    def get_file(self, file_id):
 
89
        return self.get_file_byname(self.id2path(file_id))
 
90
 
 
91
    def get_file_byname(self, filename):
 
92
        return file(self.abspath(filename), 'rb')
 
93
 
 
94
    def _get_store_filename(self, file_id):
 
95
        ## XXX: badly named; this isn't in the store at all
 
96
        return self.abspath(self.id2path(file_id))
 
97
 
 
98
 
 
99
    def id2abspath(self, file_id):
 
100
        return self.abspath(self.id2path(file_id))
 
101
 
 
102
                
 
103
    def has_id(self, file_id):
 
104
        # files that have been deleted are excluded
 
105
        inv = self._inventory
 
106
        if not inv.has_id(file_id):
 
107
            return False
 
108
        path = inv.id2path(file_id)
 
109
        return os.path.exists(self.abspath(path))
 
110
 
 
111
 
 
112
    __contains__ = has_id
 
113
    
 
114
 
 
115
    def get_file_size(self, file_id):
 
116
        return os.path.getsize(self.id2abspath(file_id))
 
117
 
 
118
 
 
119
    def get_file_sha1(self, file_id):
 
120
        path = self._inventory.id2path(file_id)
 
121
        return self._hashcache.get_sha1(path)
 
122
 
 
123
 
 
124
    def file_class(self, filename):
 
125
        if self.path2id(filename):
 
126
            return 'V'
 
127
        elif self.is_ignored(filename):
 
128
            return 'I'
 
129
        else:
 
130
            return '?'
 
131
 
 
132
 
 
133
    def list_files(self):
 
134
        """Recursively list all files as (path, class, kind, id).
 
135
 
 
136
        Lists, but does not descend into unversioned directories.
 
137
 
 
138
        This does not include files that have been deleted in this
 
139
        tree.
 
140
 
 
141
        Skips the control directory.
 
142
        """
 
143
        inv = self._inventory
 
144
 
 
145
        def descend(from_dir_relpath, from_dir_id, dp):
 
146
            ls = os.listdir(dp)
 
147
            ls.sort()
 
148
            for f in ls:
 
149
                ## TODO: If we find a subdirectory with its own .bzr
 
150
                ## directory, then that is a separate tree and we
 
151
                ## should exclude it.
 
152
                if bzrlib.BZRDIR == f:
 
153
                    continue
 
154
 
 
155
                # path within tree
 
156
                fp = appendpath(from_dir_relpath, f)
 
157
 
 
158
                # absolute path
 
159
                fap = appendpath(dp, f)
 
160
                
 
161
                f_ie = inv.get_child(from_dir_id, f)
 
162
                if f_ie:
 
163
                    c = 'V'
 
164
                elif self.is_ignored(fp):
 
165
                    c = 'I'
 
166
                else:
 
167
                    c = '?'
 
168
 
 
169
                fk = file_kind(fap)
 
170
 
 
171
                if f_ie:
 
172
                    if f_ie.kind != fk:
 
173
                        raise BzrCheckError("file %r entered as kind %r id %r, "
 
174
                                            "now of kind %r"
 
175
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
 
176
 
 
177
                yield fp, c, fk, (f_ie and f_ie.file_id)
 
178
 
 
179
                if fk != 'directory':
 
180
                    continue
 
181
 
 
182
                if c != 'V':
 
183
                    # don't descend unversioned directories
 
184
                    continue
 
185
                
 
186
                for ff in descend(fp, f_ie.file_id, fap):
 
187
                    yield ff
 
188
 
 
189
        for f in descend('', inv.root.file_id, self.basedir):
 
190
            yield f
 
191
            
 
192
 
 
193
 
 
194
    def unknowns(self):
 
195
        for subp in self.extras():
 
196
            if not self.is_ignored(subp):
 
197
                yield subp
 
198
 
 
199
    def iter_conflicts(self):
 
200
        conflicted = set()
 
201
        for path in (s[0] for s in self.list_files()):
 
202
            stem = get_conflicted_stem(path)
 
203
            if stem is None:
 
204
                continue
 
205
            if stem not in conflicted:
 
206
                conflicted.add(stem)
 
207
                yield stem
 
208
 
 
209
    def extras(self):
 
210
        """Yield all unknown files in this WorkingTree.
 
211
 
 
212
        If there are any unknown directories then only the directory is
 
213
        returned, not all its children.  But if there are unknown files
 
214
        under a versioned subdirectory, they are returned.
 
215
 
 
216
        Currently returned depth-first, sorted by name within directories.
 
217
        """
 
218
        ## TODO: Work from given directory downwards
 
219
        for path, dir_entry in self.inventory.directories():
 
220
            mutter("search for unknowns in %r" % path)
 
221
            dirabs = self.abspath(path)
 
222
            if not isdir(dirabs):
 
223
                # e.g. directory deleted
 
224
                continue
 
225
 
 
226
            fl = []
 
227
            for subf in os.listdir(dirabs):
 
228
                if (subf != '.bzr'
 
229
                    and (subf not in dir_entry.children)):
 
230
                    fl.append(subf)
 
231
            
 
232
            fl.sort()
 
233
            for subf in fl:
 
234
                subp = appendpath(path, subf)
 
235
                yield subp
 
236
 
 
237
 
 
238
    def ignored_files(self):
 
239
        """Yield list of PATH, IGNORE_PATTERN"""
 
240
        for subp in self.extras():
 
241
            pat = self.is_ignored(subp)
 
242
            if pat != None:
 
243
                yield subp, pat
 
244
 
 
245
 
 
246
    def get_ignore_list(self):
 
247
        """Return list of ignore patterns.
 
248
 
 
249
        Cached in the Tree object after the first call.
 
250
        """
 
251
        if hasattr(self, '_ignorelist'):
 
252
            return self._ignorelist
 
253
 
 
254
        l = bzrlib.DEFAULT_IGNORE[:]
 
255
        if self.has_filename(bzrlib.IGNORE_FILENAME):
 
256
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
 
257
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
 
258
        self._ignorelist = l
 
259
        return l
 
260
 
 
261
 
 
262
    def is_ignored(self, filename):
 
263
        r"""Check whether the filename matches an ignore pattern.
 
264
 
 
265
        Patterns containing '/' or '\' need to match the whole path;
 
266
        others match against only the last component.
 
267
 
 
268
        If the file is ignored, returns the pattern which caused it to
 
269
        be ignored, otherwise None.  So this can simply be used as a
 
270
        boolean if desired."""
 
271
 
 
272
        # TODO: Use '**' to match directories, and other extended
 
273
        # globbing stuff from cvs/rsync.
 
274
 
 
275
        # XXX: fnmatch is actually not quite what we want: it's only
 
276
        # approximately the same as real Unix fnmatch, and doesn't
 
277
        # treat dotfiles correctly and allows * to match /.
 
278
        # Eventually it should be replaced with something more
 
279
        # accurate.
 
280
        
 
281
        for pat in self.get_ignore_list():
 
282
            if '/' in pat or '\\' in pat:
 
283
                
 
284
                # as a special case, you can put ./ at the start of a
 
285
                # pattern; this is good to match in the top-level
 
286
                # only;
 
287
                
 
288
                if (pat[:2] == './') or (pat[:2] == '.\\'):
 
289
                    newpat = pat[2:]
 
290
                else:
 
291
                    newpat = pat
 
292
                if fnmatch.fnmatchcase(filename, newpat):
 
293
                    return pat
 
294
            else:
 
295
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
 
296
                    return pat
 
297
        else:
 
298
            return None
 
299
 
 
300
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
 
301
def get_conflicted_stem(path):
 
302
    for suffix in CONFLICT_SUFFIXES:
 
303
        if path.endswith(suffix):
 
304
            return path[:-len(suffix)]