← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

[merge] Erik Bågfors: add --revision to bzr pull

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
17
17
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
 
20
 
from sets import Set
21
 
import os.path, os, fnmatch
22
 
 
23
 
from osutils import pumpfile, filesize, quotefn, sha_file, \
24
 
     joinpath, splitpath, appendpath, isdir, isfile, file_kind, fingerprint_file
25
 
import errno
26
 
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
27
 
 
28
 
from inventory import Inventory
29
 
from trace import mutter, note
30
 
from errors import bailout
31
 
import branch
 
20
import os
 
21
from cStringIO import StringIO
32
22
 
33
23
import bzrlib
 
24
from bzrlib.trace import mutter, note
 
25
from bzrlib.errors import BzrError, BzrCheckError
 
26
from bzrlib.inventory import Inventory
 
27
from bzrlib.osutils import appendpath, fingerprint_file
34
28
 
35
 
class Tree:
 
29
class Tree(object):
36
30
    """Abstract file tree.
37
31
 
38
32
    There are several subclasses:
61
55
    def has_id(self, file_id):
62
56
        return self.inventory.has_id(file_id)
63
57
 
 
58
    def has_or_had_id(self, file_id):
 
59
        if file_id == self.inventory.root.file_id:
 
60
            return True
 
61
        return self.inventory.has_id(file_id)
 
62
 
64
63
    __contains__ = has_id
65
64
 
66
 
    def id_set(self):
67
 
        """Return set of all ids in this tree."""
68
 
        return self.inventory.id_set()
69
 
 
70
65
    def __iter__(self):
71
66
        return iter(self.inventory)
72
67
 
73
68
    def id2path(self, file_id):
74
69
        return self.inventory.id2path(file_id)
75
70
 
 
71
    def kind(self, file_id):
 
72
        raise NotImplementedError("subclasses must implement kind")
 
73
 
76
74
    def _get_inventory(self):
77
75
        return self._inventory
 
76
    
 
77
    def get_file_by_path(self, path):
 
78
        return self.get_file(self._inventory.path2id(path))
78
79
 
79
80
    inventory = property(_get_inventory,
80
81
                         doc="Inventory of this Tree")
81
82
 
82
83
    def _check_retrieved(self, ie, f):
 
84
        if not __debug__:
 
85
            return  
83
86
        fp = fingerprint_file(f)
84
87
        f.seek(0)
85
88
        
86
89
        if ie.text_size != None:
87
90
            if ie.text_size != fp['size']:
88
 
                bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
91
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
89
92
                        ["inventory expects %d bytes" % ie.text_size,
90
93
                         "file is actually %d bytes" % fp['size'],
91
94
                         "store is probably damaged/corrupt"])
92
95
 
93
96
        if ie.text_sha1 != fp['sha1']:
94
 
            bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
97
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
95
98
                    ["inventory expects %s" % ie.text_sha1,
96
99
                     "file is actually %s" % fp['sha1'],
97
100
                     "store is probably damaged/corrupt"])
98
101
 
99
102
 
100
 
    def print_file(self, fileid):
101
 
        """Print file with id `fileid` to stdout."""
 
103
    def print_file(self, file_id):
 
104
        """Print file with id `file_id` to stdout."""
102
105
        import sys
103
 
        pumpfile(self.get_file(fileid), sys.stdout)
104
 
        
105
 
        
106
 
    def export(self, dest):        
107
 
        """Export this tree to a new directory.
108
 
 
109
 
        `dest` should not exist, and will be created holding the
110
 
        contents of this tree.
111
 
 
112
 
        TODO: To handle subdirectories we need to create the
113
 
               directories first.
114
 
 
115
 
        :note: If the export fails, the destination directory will be
116
 
               left in a half-assed state.
117
 
        """
118
 
        os.mkdir(dest)
119
 
        mutter('export version %r' % self)
120
 
        inv = self.inventory
121
 
        for dp, ie in inv.iter_entries():
122
 
            kind = ie.kind
123
 
            fullpath = appendpath(dest, dp)
124
 
            if kind == 'directory':
125
 
                os.mkdir(fullpath)
126
 
            elif kind == 'file':
127
 
                pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
128
 
            else:
129
 
                bailout("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
130
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
131
 
 
132
 
 
133
 
 
 
106
        sys.stdout.write(self.get_file_text(file_id))
 
107
 
 
108
    def lock_read(self):
 
109
        pass
 
110
 
 
111
    def unlock(self):
 
112
        pass
 
113
        
 
114
        
134
115
class RevisionTree(Tree):
135
116
    """Tree viewing a previous revision.
136
117
 
141
122
           or at least passing a description to the constructor.
142
123
    """
143
124
    
144
 
    def __init__(self, store, inv):
145
 
        self._store = store
 
125
    def __init__(self, branch, inv, revision_id):
 
126
        self._branch = branch
 
127
        self._weave_store = branch.weave_store
146
128
        self._inventory = inv
 
129
        self._revision_id = revision_id
 
130
 
 
131
    def get_weave(self, file_id):
 
132
        import bzrlib.transactions as transactions
 
133
        return self._weave_store.get_weave(file_id,
 
134
                self._branch.get_transaction())
 
135
 
 
136
    def get_weave_prelude(self, file_id):
 
137
        import bzrlib.transactions as transactions
 
138
        return self._weave_store.get_weave_prelude(file_id,
 
139
                self._branch.get_transaction())
 
140
 
 
141
    def get_file_lines(self, file_id):
 
142
        ie = self._inventory[file_id]
 
143
        weave = self.get_weave(file_id)
 
144
        return weave.get(ie.revision)
 
145
 
 
146
    def get_file_text(self, file_id):
 
147
        return ''.join(self.get_file_lines(file_id))
147
148
 
148
149
    def get_file(self, file_id):
149
 
        ie = self._inventory[file_id]
150
 
        f = self._store[ie.text_id]
151
 
        mutter("  get fileid{%s} from %r" % (file_id, self))
152
 
        self._check_retrieved(ie, f)
153
 
        return f
 
150
        return StringIO(self.get_file_text(file_id))
154
151
 
155
152
    def get_file_size(self, file_id):
156
153
        return self._inventory[file_id].text_size
157
154
 
158
155
    def get_file_sha1(self, file_id):
159
156
        ie = self._inventory[file_id]
160
 
        return ie.text_sha1
 
157
        if ie.kind == "file":
 
158
            return ie.text_sha1
 
159
 
 
160
    def is_executable(self, file_id):
 
161
        ie = self._inventory[file_id]
 
162
        if ie.kind != "file":
 
163
            return None 
 
164
        return self._inventory[file_id].executable
161
165
 
162
166
    def has_filename(self, filename):
163
167
        return bool(self.inventory.path2id(filename))
165
169
    def list_files(self):
166
170
        # The only files returned by this are those from the version
167
171
        for path, entry in self.inventory.iter_entries():
168
 
            yield path, 'V', entry.kind, entry.file_id
 
172
            yield path, 'V', entry.kind, entry.file_id, entry
 
173
 
 
174
    def get_symlink_target(self, file_id):
 
175
        ie = self._inventory[file_id]
 
176
        return ie.symlink_target;
 
177
 
 
178
    def kind(self, file_id):
 
179
        return self._inventory[file_id].kind
 
180
 
 
181
    def lock_read(self):
 
182
        self._branch.lock_read()
 
183
 
 
184
    def unlock(self):
 
185
        self._branch.unlock()
169
186
 
170
187
 
171
188
class EmptyTree(Tree):
172
189
    def __init__(self):
173
190
        self._inventory = Inventory()
174
191
 
 
192
    def get_symlink_target(self, file_id):
 
193
        return None
 
194
 
175
195
    def has_filename(self, filename):
176
196
        return False
177
197
 
 
198
    def kind(self, file_id):
 
199
        assert self._inventory[file_id].kind == "root_directory"
 
200
        return "root_directory"
 
201
 
178
202
    def list_files(self):
179
 
        if False:  # just to make it a generator
180
 
            yield None
 
203
        return iter([])
181
204
    
 
205
    def __contains__(self, file_id):
 
206
        return file_id in self._inventory
 
207
 
 
208
    def get_file_sha1(self, file_id):
 
209
        assert self._inventory[file_id].kind == "root_directory"
 
210
        return None
182
211
 
183
212
 
184
213
######################################################################
245
274
        if old_name != new_name:
246
275
            yield (old_name, new_name)
247
276
            
 
277
 
 
278