← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/testament.py

  • Committer: Robert Collins
  • Date: 2005-10-14 02:17:36 UTC
  • mfrom: (1185.16.34)
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051014021736-7230e59066856096
Merge from Martin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/testament.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005 by 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
69
69
# TODO: Perhaps these should just be different formats in which inventories/
70
70
# revisions can be serialized.
71
71
 
72
 
from copy import copy
 
72
from cStringIO import StringIO
 
73
import string
73
74
from sha import sha
74
75
 
75
 
from bzrlib.osutils import contains_whitespace, contains_linebreaks
76
 
 
77
 
 
 
76
 
 
77
def contains_whitespace(s):
 
78
    """True if there are any whitespace characters in s."""
 
79
    for ch in string.whitespace:
 
80
        if ch in s:
 
81
            return True
 
82
    else:
 
83
        return False
 
84
 
 
85
 
 
86
def contains_linebreaks(s):
 
87
    """True if there is any vertical whitespace in s."""
 
88
    for ch in '\f\n\r':
 
89
        if ch in s:
 
90
            return True
 
91
    else:
 
92
        return False
 
93
 
 
94
    
78
95
class Testament(object):
79
96
    """Reduced summary of a revision.
80
97
 
81
98
    Testaments can be 
82
99
 
83
100
      - produced from a revision
84
 
      - written to a stream
 
101
      - writen to a stream
85
102
      - loaded from a stream
86
103
      - compared to a revision
87
104
    """
88
105
 
89
 
    long_header = 'bazaar-ng testament version 1\n'
90
 
    short_header = 'bazaar-ng testament short form 1\n'
91
 
 
92
106
    @classmethod
93
 
    def from_revision(cls, repository, revision_id):
 
107
    def from_revision(cls, branch, revision_id):
94
108
        """Produce a new testament from a historical revision"""
95
 
        rev = repository.get_revision(revision_id)
96
 
        inventory = repository.get_inventory(revision_id)
97
 
        return cls(rev, inventory)
98
 
 
99
 
    def __init__(self, rev, inventory):
100
 
        """Create a new testament for rev using inventory."""
101
 
        self.revision_id = str(rev.revision_id)
102
 
        self.committer = rev.committer
103
 
        self.timezone = rev.timezone or 0
104
 
        self.timestamp = rev.timestamp
105
 
        self.message = rev.message
106
 
        self.parent_ids = rev.parent_ids[:]
107
 
        self.inventory = inventory
108
 
        self.revprops = copy(rev.properties)
109
 
        assert not contains_whitespace(self.revision_id)
110
 
        assert not contains_linebreaks(self.committer)
 
109
        t = cls()
 
110
        rev = branch.get_revision(revision_id)
 
111
        t.revision_id = str(revision_id)
 
112
        t.committer = rev.committer
 
113
        t.timezone = rev.timezone or 0
 
114
        t.timestamp = rev.timestamp
 
115
        t.message = rev.message
 
116
        t.parent_ids = rev.parent_ids[:]
 
117
        t.inventory = branch.get_inventory(revision_id)
 
118
        assert not contains_whitespace(t.revision_id)
 
119
        assert not contains_linebreaks(t.committer)
 
120
        return t
111
121
 
112
122
    def as_text_lines(self):
113
123
        """Yield text form as a sequence of lines.
116
126
        hashed in that encoding.
117
127
        """
118
128
        r = []
119
 
        a = r.append
120
 
        a(self.long_header)
 
129
        def a(s):
 
130
            r.append(s)
 
131
        a('bazaar-ng testament version 1\n')
121
132
        a('revision-id: %s\n' % self.revision_id)
122
133
        a('committer: %s\n' % self.committer)
123
134
        a('timestamp: %d\n' % self.timestamp)
131
142
        for l in self.message.splitlines():
132
143
            a('  %s\n' % l)
133
144
        a('inventory:\n')
134
 
        for path, ie in self._get_entries():
 
145
        for path, ie in self.inventory.iter_entries():
135
146
            a(self._entry_to_line(path, ie))
136
 
        r.extend(self._revprops_to_lines())
137
147
        if __debug__:
138
148
            for l in r:
139
 
                assert isinstance(l, basestring), \
 
149
                assert isinstance(l, str), \
140
150
                    '%r of type %s is not a plain string' % (l, type(l))
141
 
        return [line.encode('utf-8') for line in r]
142
 
 
143
 
    def _get_entries(self):
144
 
        entries = self.inventory.iter_entries()
145
 
        entries.next()
146
 
        return entries
 
151
        return r
147
152
 
148
153
    def _escape_path(self, path):
149
154
        assert not contains_linebreaks(path)
150
 
        return unicode(path.replace('\\', '/').replace(' ', '\ '))
 
155
        return unicode(path.replace('\\', '/').replace(' ', '\ ')).encode('utf-8')
151
156
 
152
157
    def _entry_to_line(self, path, ie):
153
158
        """Turn an inventory entry into a testament line"""
 
159
        l = '  ' + str(ie.kind)
 
160
        l += ' ' + self._escape_path(path)
154
161
        assert not contains_whitespace(ie.file_id)
155
 
 
156
 
        content = ''
157
 
        content_spacer=''
 
162
        l += ' ' + unicode(ie.file_id).encode('utf-8')
158
163
        if ie.kind == 'file':
159
164
            # TODO: avoid switching on kind
160
165
            assert ie.text_sha1
161
 
            content = ie.text_sha1
162
 
            content_spacer = ' '
 
166
            l += ' ' + ie.text_sha1
163
167
        elif ie.kind == 'symlink':
164
168
            assert ie.symlink_target
165
 
            content = self._escape_path(ie.symlink_target)
166
 
            content_spacer = ' '
167
 
 
168
 
        l = u'  %s %s %s%s%s\n' % (ie.kind, self._escape_path(path),
169
 
                                   unicode(ie.file_id),
170
 
                                   content_spacer, content)
 
169
            l += ' ' + self._escape_path(ie.symlink_target)
 
170
        l += '\n'
171
171
        return l
172
172
 
173
173
    def as_text(self):
175
175
 
176
176
    def as_short_text(self):
177
177
        """Return short digest-based testament."""
178
 
        return (self.short_header + 
 
178
        s = sha()
 
179
        map(s.update, self.as_text_lines())
 
180
        return ('bazaar-ng testament short form 1\n'
179
181
                'revision-id: %s\n'
180
182
                'sha1: %s\n'
181
 
                % (self.revision_id, self.as_sha1()))
182
 
 
183
 
    def _revprops_to_lines(self):
184
 
        """Pack up revision properties."""
185
 
        if not self.revprops:
186
 
            return []
187
 
        r = ['properties:\n']
188
 
        for name, value in sorted(self.revprops.items()):
189
 
            assert isinstance(name, str)
190
 
            assert not contains_whitespace(name)
191
 
            r.append('  %s:\n' % name)
192
 
            for line in value.splitlines():
193
 
                r.append(u'    %s\n' % line)
194
 
        return r
195
 
 
196
 
    def as_sha1(self):
197
 
        s = sha()
198
 
        map(s.update, self.as_text_lines())
199
 
        return s.hexdigest()
200
 
 
201
 
 
202
 
class StrictTestament(Testament):
203
 
    """This testament format is for use as a checksum in bundle format 0.8"""
204
 
 
205
 
    long_header = 'bazaar-ng testament version 2.1\n'
206
 
    short_header = 'bazaar-ng testament short form 2.1\n'
207
 
    def _entry_to_line(self, path, ie):
208
 
        l = Testament._entry_to_line(self, path, ie)[:-1]
209
 
        l += ' ' + ie.revision
210
 
        l += {True: ' yes\n', False: ' no\n'}[ie.executable]
211
 
        return l
212
 
 
213
 
 
214
 
class StrictTestament3(StrictTestament):
215
 
    """This testament format is for use as a checksum in bundle format 0.9+
216
 
    
217
 
    It differs from StrictTestament by including data about the tree root.
218
 
    """
219
 
 
220
 
    long_header = 'bazaar testament version 3 strict\n'
221
 
    short_header = 'bazaar testament short form 3 strict\n'
222
 
    def _get_entries(self):
223
 
        return self.inventory.iter_entries()
224
 
 
225
 
    def _escape_path(self, path):
226
 
        assert not contains_linebreaks(path)
227
 
        if path == '':
228
 
            path = '.'
229
 
        return unicode(path.replace('\\', '/').replace(' ', '\ '))
 
183
                % (self.revision_id, s.hexdigest()))
 
184