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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-28 16:52:19 UTC
  • mfrom: (1558.14.10 Aaron's integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060728165219-3a441adb0af54ef8
Copyright statements use # to start all lines

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
1
1
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
"""
19
19
 
20
20
import os
 
21
from cStringIO import StringIO
 
22
from warnings import warn
21
23
 
22
24
import bzrlib
 
25
from bzrlib.errors import BzrError, BzrCheckError
 
26
from bzrlib import errors
 
27
from bzrlib.inventory import Inventory
 
28
from bzrlib.osutils import fingerprint_file
 
29
import bzrlib.revision
23
30
from bzrlib.trace import mutter, note
24
 
from bzrlib.errors import BzrError
25
 
from bzrlib.inventory import Inventory
26
 
from bzrlib.osutils import pumpfile, appendpath, fingerprint_file
27
 
 
28
 
 
29
 
exporters = {}
 
31
 
30
32
 
31
33
class Tree(object):
32
34
    """Abstract file tree.
37
39
 
38
40
    * `RevisionTree` is a tree as recorded at some point in the past.
39
41
 
40
 
    * `EmptyTree`
41
 
 
42
42
    Trees contain an `Inventory` object, and also know how to retrieve
43
43
    file texts mentioned in the inventory, either from a working
44
44
    directory or from a store.
50
50
    trees or versioned trees.
51
51
    """
52
52
    
 
53
    def conflicts(self):
 
54
        """Get a list of the conflicts in the tree.
 
55
 
 
56
        Each conflict is an instance of bzrlib.conflicts.Conflict.
 
57
        """
 
58
        return []
 
59
 
 
60
    def get_parent_ids(self):
 
61
        """Get the parent ids for this tree. 
 
62
 
 
63
        :return: a list of parent ids. [] is returned to indicate
 
64
        a tree with no parents.
 
65
        :raises: BzrError if the parents are not known.
 
66
        """
 
67
        raise NotImplementedError(self.get_parent_ids)
 
68
    
53
69
    def has_filename(self, filename):
54
70
        """True if the tree has given filename."""
55
71
        raise NotImplementedError()
57
73
    def has_id(self, file_id):
58
74
        return self.inventory.has_id(file_id)
59
75
 
 
76
    def has_or_had_id(self, file_id):
 
77
        if file_id == self.inventory.root.file_id:
 
78
            return True
 
79
        return self.inventory.has_id(file_id)
 
80
 
60
81
    __contains__ = has_id
61
82
 
62
83
    def __iter__(self):
65
86
    def id2path(self, file_id):
66
87
        return self.inventory.id2path(file_id)
67
88
 
 
89
    def kind(self, file_id):
 
90
        raise NotImplementedError("subclasses must implement kind")
 
91
 
68
92
    def _get_inventory(self):
69
93
        return self._inventory
70
94
    
75
99
                         doc="Inventory of this Tree")
76
100
 
77
101
    def _check_retrieved(self, ie, f):
 
102
        if not __debug__:
 
103
            return  
78
104
        fp = fingerprint_file(f)
79
105
        f.seek(0)
80
106
        
92
118
                     "store is probably damaged/corrupt"])
93
119
 
94
120
 
95
 
    def print_file(self, fileid):
96
 
        """Print file with id `fileid` to stdout."""
 
121
    def print_file(self, file_id):
 
122
        """Print file with id `file_id` to stdout."""
97
123
        import sys
98
 
        pumpfile(self.get_file(fileid), sys.stdout)
99
 
        
100
 
        
101
 
    def export(self, dest, format='dir', root=None):
102
 
        """Export this tree."""
103
 
        try:
104
 
            exporter = exporters[format]
105
 
        except KeyError:
106
 
            from bzrlib.errors import BzrCommandError
107
 
            raise BzrCommandError("export format %r not supported" % format)
108
 
        exporter(self, dest, root)
109
 
 
110
 
 
111
 
 
 
124
        sys.stdout.write(self.get_file_text(file_id))
 
125
 
 
126
    def lock_read(self):
 
127
        pass
 
128
 
 
129
    def unknowns(self):
 
130
        """What files are present in this tree and unknown.
 
131
        
 
132
        :return: an iterator over the unknown files.
 
133
        """
 
134
        return iter([])
 
135
 
 
136
    def unlock(self):
 
137
        pass
 
138
 
 
139
    def filter_unversioned_files(self, paths):
 
140
        """Filter out paths that are not versioned.
 
141
 
 
142
        :return: set of paths.
 
143
        """
 
144
        # NB: we specifically *don't* call self.has_filename, because for
 
145
        # WorkingTrees that can indicate files that exist on disk but that 
 
146
        # are not versioned.
 
147
        pred = self.inventory.has_filename
 
148
        return set((p for p in paths if not pred(p)))
 
149
        
 
150
        
112
151
class RevisionTree(Tree):
113
152
    """Tree viewing a previous revision.
114
153
 
119
158
           or at least passing a description to the constructor.
120
159
    """
121
160
    
122
 
    def __init__(self, store, inv):
123
 
        self._store = store
 
161
    def __init__(self, branch, inv, revision_id):
 
162
        # for compatability the 'branch' parameter has not been renamed to 
 
163
        # repository at this point. However, we should change RevisionTree's
 
164
        # construction to always be via Repository and not via direct 
 
165
        # construction - this will mean that we can change the constructor
 
166
        # with much less chance of breaking client code.
 
167
        self._repository = branch
 
168
        self._weave_store = branch.weave_store
124
169
        self._inventory = inv
 
170
        self._revision_id = revision_id
 
171
 
 
172
    def get_parent_ids(self):
 
173
        """See Tree.get_parent_ids.
 
174
 
 
175
        A RevisionTree's parents match the revision graph.
 
176
        """
 
177
        parent_ids = self._repository.get_revision(self._revision_id).parent_ids
 
178
        return parent_ids
 
179
        
 
180
    def get_revision_id(self):
 
181
        """Return the revision id associated with this tree."""
 
182
        return self._revision_id
 
183
 
 
184
    def get_weave(self, file_id):
 
185
        return self._weave_store.get_weave(file_id,
 
186
                self._repository.get_transaction())
 
187
 
 
188
    def get_file_lines(self, file_id):
 
189
        ie = self._inventory[file_id]
 
190
        weave = self.get_weave(file_id)
 
191
        return weave.get_lines(ie.revision)
 
192
 
 
193
    def get_file_text(self, file_id):
 
194
        return ''.join(self.get_file_lines(file_id))
125
195
 
126
196
    def get_file(self, file_id):
127
 
        ie = self._inventory[file_id]
128
 
        f = self._store[ie.text_id]
129
 
        mutter("  get fileid{%s} from %r" % (file_id, self))
130
 
        self._check_retrieved(ie, f)
131
 
        return f
 
197
        return StringIO(self.get_file_text(file_id))
132
198
 
133
199
    def get_file_size(self, file_id):
134
200
        return self._inventory[file_id].text_size
135
201
 
136
 
    def get_file_sha1(self, file_id):
137
 
        ie = self._inventory[file_id]
138
 
        return ie.text_sha1
 
202
    def get_file_sha1(self, file_id, path=None):
 
203
        ie = self._inventory[file_id]
 
204
        if ie.kind == "file":
 
205
            return ie.text_sha1
 
206
        return None
 
207
 
 
208
    def get_file_mtime(self, file_id, path=None):
 
209
        ie = self._inventory[file_id]
 
210
        revision = self._repository.get_revision(ie.revision)
 
211
        return revision.timestamp
 
212
 
 
213
    def is_executable(self, file_id, path=None):
 
214
        ie = self._inventory[file_id]
 
215
        if ie.kind != "file":
 
216
            return None 
 
217
        return self._inventory[file_id].executable
139
218
 
140
219
    def has_filename(self, filename):
141
220
        return bool(self.inventory.path2id(filename))
143
222
    def list_files(self):
144
223
        # The only files returned by this are those from the version
145
224
        for path, entry in self.inventory.iter_entries():
146
 
            yield path, 'V', entry.kind, entry.file_id
 
225
            yield path, 'V', entry.kind, entry.file_id, entry
 
226
 
 
227
    def get_symlink_target(self, file_id):
 
228
        ie = self._inventory[file_id]
 
229
        return ie.symlink_target;
 
230
 
 
231
    def kind(self, file_id):
 
232
        return self._inventory[file_id].kind
 
233
 
 
234
    def lock_read(self):
 
235
        self._repository.lock_read()
 
236
 
 
237
    def unlock(self):
 
238
        self._repository.unlock()
147
239
 
148
240
 
149
241
class EmptyTree(Tree):
 
242
 
150
243
    def __init__(self):
151
244
        self._inventory = Inventory()
 
245
        warn('EmptyTree is deprecated as of bzr 0.9 please use '
 
246
            'repository.revision_tree instead.',
 
247
            DeprecationWarning, stacklevel=2)
 
248
 
 
249
    def get_parent_ids(self):
 
250
        return []
 
251
 
 
252
    def get_symlink_target(self, file_id):
 
253
        return None
152
254
 
153
255
    def has_filename(self, filename):
154
256
        return False
155
257
 
 
258
    def kind(self, file_id):
 
259
        assert self._inventory[file_id].kind == "root_directory"
 
260
        return "root_directory"
 
261
 
156
262
    def list_files(self):
157
 
        if False:  # just to make it a generator
158
 
            yield None
 
263
        return iter([])
159
264
    
 
265
    def __contains__(self, file_id):
 
266
        return file_id in self._inventory
 
267
 
 
268
    def get_file_sha1(self, file_id, path=None):
 
269
        assert self._inventory[file_id].kind == "root_directory"
 
270
        return None
160
271
 
161
272
 
162
273
######################################################################
224
335
            yield (old_name, new_name)
225
336
            
226
337
 
227
 
 
228
 
######################################################################
229
 
# export
230
 
 
231
 
def dir_exporter(tree, dest, root):
232
 
    """Export this tree to a new directory.
233
 
 
234
 
    `dest` should not exist, and will be created holding the
235
 
    contents of this tree.
236
 
 
237
 
    TODO: To handle subdirectories we need to create the
238
 
           directories first.
239
 
 
240
 
    :note: If the export fails, the destination directory will be
241
 
           left in a half-assed state.
242
 
    """
243
 
    import os
244
 
    os.mkdir(dest)
245
 
    mutter('export version %r' % tree)
246
 
    inv = tree.inventory
247
 
    for dp, ie in inv.iter_entries():
248
 
        kind = ie.kind
249
 
        fullpath = appendpath(dest, dp)
250
 
        if kind == 'directory':
251
 
            os.mkdir(fullpath)
252
 
        elif kind == 'file':
253
 
            pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
254
 
        else:
255
 
            raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
256
 
        mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
257
 
exporters['dir'] = dir_exporter
258
 
 
259
 
try:
260
 
    import tarfile
261
 
except ImportError:
262
 
    pass
263
 
else:
264
 
    def get_root_name(dest):
265
 
        """Get just the root name for a tarball.
266
 
 
267
 
        >>> get_root_name('mytar.tar')
268
 
        'mytar'
269
 
        >>> get_root_name('mytar.tar.bz2')
270
 
        'mytar'
271
 
        >>> get_root_name('tar.tar.tar.tgz')
272
 
        'tar.tar.tar'
273
 
        >>> get_root_name('bzr-0.0.5.tar.gz')
274
 
        'bzr-0.0.5'
275
 
        >>> get_root_name('a/long/path/mytar.tgz')
276
 
        'mytar'
277
 
        >>> get_root_name('../parent/../dir/other.tbz2')
278
 
        'other'
279
 
        """
280
 
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
281
 
        dest = os.path.basename(dest)
282
 
        for end in endings:
283
 
            if dest.endswith(end):
284
 
                return dest[:-len(end)]
285
 
 
286
 
    def tar_exporter(tree, dest, root, compression=None):
287
 
        """Export this tree to a new tar file.
288
 
 
289
 
        `dest` will be created holding the contents of this tree; if it
290
 
        already exists, it will be clobbered, like with "tar -c".
291
 
        """
292
 
        from time import time
293
 
        now = time()
294
 
        compression = str(compression or '')
295
 
        if root is None:
296
 
            root = get_root_name(dest)
297
 
        try:
298
 
            ball = tarfile.open(dest, 'w:' + compression)
299
 
        except tarfile.CompressionError, e:
300
 
            raise BzrError(str(e))
301
 
        mutter('export version %r' % tree)
302
 
        inv = tree.inventory
303
 
        for dp, ie in inv.iter_entries():
304
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
305
 
            item = tarfile.TarInfo(os.path.join(root, dp))
306
 
            # TODO: would be cool to actually set it to the timestamp of the
307
 
            # revision it was last changed
308
 
            item.mtime = now
309
 
            if ie.kind == 'directory':
310
 
                item.type = tarfile.DIRTYPE
311
 
                fileobj = None
312
 
                item.name += '/'
313
 
                item.size = 0
314
 
                item.mode = 0755
315
 
            elif ie.kind == 'file':
316
 
                item.type = tarfile.REGTYPE
317
 
                fileobj = tree.get_file(ie.file_id)
318
 
                item.size = _find_file_size(fileobj)
319
 
                item.mode = 0644
320
 
            else:
321
 
                raise BzrError("don't know how to export {%s} of kind %r" %
322
 
                        (ie.file_id, ie.kind))
323
 
 
324
 
            ball.addfile(item, fileobj)
325
 
        ball.close()
326
 
    exporters['tar'] = tar_exporter
327
 
 
328
 
    def tgz_exporter(tree, dest, root):
329
 
        tar_exporter(tree, dest, root, compression='gz')
330
 
    exporters['tgz'] = tgz_exporter
331
 
 
332
 
    def tbz_exporter(tree, dest, root):
333
 
        tar_exporter(tree, dest, root, compression='bz2')
334
 
    exporters['tbz2'] = tbz_exporter
335
 
 
336
 
 
337
 
def _find_file_size(fileobj):
338
 
    offset = fileobj.tell()
339
 
    try:
340
 
        fileobj.seek(0, 2)
341
 
        size = fileobj.tell()
342
 
    except TypeError:
343
 
        # gzip doesn't accept second argument to seek()
344
 
        fileobj.seek(0)
345
 
        size = 0
346
 
        while True:
347
 
            nread = len(fileobj.read())
348
 
            if nread == 0:
349
 
                break
350
 
            size += nread
351
 
    fileobj.seek(offset)
352
 
    return size
 
338
def find_ids_across_trees(filenames, trees, require_versioned=True):
 
339
    """Find the ids corresponding to specified filenames.
 
340
    
 
341
    All matches in all trees will be used, and all children of matched
 
342
    directories will be used.
 
343
 
 
344
    :param filenames: The filenames to find file_ids for
 
345
    :param trees: The trees to find file_ids within
 
346
    :param require_versioned: if true, all specified filenames must occur in
 
347
    at least one tree.
 
348
    :return: a set of file ids for the specified filenames and their children.
 
349
    """
 
350
    if not filenames:
 
351
        return None
 
352
    specified_ids = _find_filename_ids_across_trees(filenames, trees, 
 
353
                                                    require_versioned)
 
354
    return _find_children_across_trees(specified_ids, trees)
 
355
 
 
356
 
 
357
def _find_filename_ids_across_trees(filenames, trees, require_versioned):
 
358
    """Find the ids corresponding to specified filenames.
 
359
    
 
360
    All matches in all trees will be used.
 
361
 
 
362
    :param filenames: The filenames to find file_ids for
 
363
    :param trees: The trees to find file_ids within
 
364
    :param require_versioned: if true, all specified filenames must occur in
 
365
    at least one tree.
 
366
    :return: a set of file ids for the specified filenames
 
367
    """
 
368
    not_versioned = []
 
369
    interesting_ids = set()
 
370
    for tree_path in filenames:
 
371
        not_found = True
 
372
        for tree in trees:
 
373
            file_id = tree.inventory.path2id(tree_path)
 
374
            if file_id is not None:
 
375
                interesting_ids.add(file_id)
 
376
                not_found = False
 
377
        if not_found:
 
378
            not_versioned.append(tree_path)
 
379
    if len(not_versioned) > 0 and require_versioned:
 
380
        raise errors.PathsNotVersionedError(not_versioned)
 
381
    return interesting_ids
 
382
 
 
383
 
 
384
def _find_children_across_trees(specified_ids, trees):
 
385
    """Return a set including specified ids and their children
 
386
    
 
387
    All matches in all trees will be used.
 
388
 
 
389
    :param trees: The trees to find file_ids within
 
390
    :return: a set containing all specified ids and their children 
 
391
    """
 
392
    interesting_ids = set(specified_ids)
 
393
    pending = interesting_ids
 
394
    # now handle children of interesting ids
 
395
    # we loop so that we handle all children of each id in both trees
 
396
    while len(pending) > 0:
 
397
        new_pending = set()
 
398
        for file_id in pending:
 
399
            for tree in trees:
 
400
                if file_id not in tree:
 
401
                    continue
 
402
                entry = tree.inventory[file_id]
 
403
                for child in getattr(entry, 'children', {}).itervalues():
 
404
                    if child.file_id not in interesting_ids:
 
405
                        new_pending.add(child.file_id)
 
406
        interesting_ids.update(new_pending)
 
407
        pending = new_pending
 
408
    return interesting_ids