← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/serializer/v08.py

  • Committer: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/serializer/v08.py
1
 
# Copyright (C) 2005, 2006, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Serializer factory for reading and writing bundles.
18
18
"""
19
19
 
20
20
import os
21
21
 
22
 
from bzrlib import (
23
 
    errors,
24
 
    ui,
25
 
    )
 
22
from bzrlib import errors
26
23
from bzrlib.bundle.serializer import (BundleSerializer,
27
 
                                      _get_bundle_header,
 
24
                                      BUNDLE_HEADER,
28
25
                                     )
29
26
from bzrlib.bundle.serializer import binary_diff
30
27
from bzrlib.bundle.bundle_data import (RevisionInfo, BundleInfo, BundleTree)
31
28
from bzrlib.diff import internal_diff
32
29
from bzrlib.osutils import pathjoin
 
30
from bzrlib.progress import DummyProgress
33
31
from bzrlib.revision import NULL_REVISION
 
32
import bzrlib.ui
34
33
from bzrlib.testament import StrictTestament
35
34
from bzrlib.timestamp import (
36
35
    format_highres_date,
120
119
        source.lock_read()
121
120
        try:
122
121
            self._write_main_header()
123
 
            pb = ui.ui_factory.nested_progress_bar()
 
122
            pb = DummyProgress()
124
123
            try:
125
124
                self._write_revisions(pb)
126
125
            finally:
127
 
                pb.finished()
 
126
                pass
 
127
                #pb.finished()
128
128
        finally:
129
129
            source.unlock()
130
130
 
131
 
    def write_bundle(self, repository, target, base, fileobj):
132
 
        return self._write_bundle(repository, target, base, fileobj)
133
 
 
134
131
    def _write_main_header(self):
135
132
        """Write the header for the changes"""
136
133
        f = self.to_file
137
 
        f.write(_get_bundle_header('0.8'))
 
134
        f.write(BUNDLE_HEADER)
 
135
        f.write('0.8\n')
138
136
        f.write('#\n')
139
137
 
140
138
    def _write(self, key, value, indent=1, trailing_space_when_empty=False):
146
144
            If this parameter is True, and value is the empty string, we will
147
145
            write an extra space.
148
146
        """
149
 
        if indent < 1:
150
 
            raise ValueError('indentation must be greater than 0')
 
147
        assert indent > 0, 'indentation must be greater than 0'
151
148
        f = self.to_file
152
149
        f.write('#' + (' ' * indent))
153
150
        f.write(key.encode('utf-8'))
183
180
 
184
181
        i_max = len(self.revision_ids)
185
182
        for i, rev_id in enumerate(self.revision_ids):
186
 
            pb.update("Generating revision data", i, i_max)
 
183
            pb.update("Generating revsion data", i, i_max)
187
184
            rev = self.source.get_revision(rev_id)
188
185
            if rev_id == last_rev_id:
189
186
                rev_tree = last_rev_tree
206
203
            else:
207
204
                base_tree = self.source.revision_tree(base_id)
208
205
            force_binary = (i != 0)
209
 
            self._write_revision(rev, rev_tree, base_id, base_tree,
 
206
            self._write_revision(rev, rev_tree, base_id, base_tree, 
210
207
                                 explicit_base, force_binary)
211
208
 
212
209
            last_rev_id = base_id
213
210
            last_rev_tree = base_tree
214
211
 
215
212
    def _testament_sha1(self, revision_id):
216
 
        return StrictTestament.from_revision(self.source,
 
213
        return StrictTestament.from_revision(self.source, 
217
214
                                             revision_id).as_sha1()
218
215
 
219
 
    def _write_revision(self, rev, rev_tree, base_rev, base_tree,
 
216
    def _write_revision(self, rev, rev_tree, base_rev, base_tree, 
220
217
                        explicit_base, force_binary):
221
218
        """Write out the information for a revision."""
222
219
        def w(key, value):
241
238
            for name, value in sorted(rev.properties.items()):
242
239
                self._write(name, value, indent=3,
243
240
                            trailing_space_when_empty=True)
244
 
 
 
241
        
245
242
        # Add an extra blank space at the end
246
243
        self.to_file.write('\n')
247
244
 
254
251
        self.to_file.write(' // '.join(p_texts).encode('utf-8'))
255
252
        self.to_file.write('\n')
256
253
 
257
 
    def _write_delta(self, new_tree, old_tree, default_revision_id,
 
254
    def _write_delta(self, new_tree, old_tree, default_revision_id, 
258
255
                     force_binary):
259
256
        """Write out the changes between the trees."""
260
257
        DEVNULL = '/dev/null'
277
274
                old_lines = tree_lines(old_tree, require_text=True)
278
275
                new_lines = tree_lines(new_tree, require_text=True)
279
276
                action.write(self.to_file)
280
 
                internal_diff(old_path, old_lines, new_path, new_lines,
 
277
                internal_diff(old_path, old_lines, new_path, new_lines, 
281
278
                              self.to_file)
282
279
            except errors.BinaryFile:
283
280
                old_lines = tree_lines(old_tree, require_text=False)
284
281
                new_lines = tree_lines(new_tree, require_text=False)
285
282
                action.add_property('encoding', 'base64')
286
283
                action.write(self.to_file)
287
 
                binary_diff(old_path, old_lines, new_path, new_lines,
 
284
                binary_diff(old_path, old_lines, new_path, new_lines, 
288
285
                            self.to_file)
289
286
 
290
287
        def finish_action(action, file_id, kind, meta_modified, text_modified,
308
305
 
309
306
        for path, file_id, kind in delta.added:
310
307
            action = Action('added', [kind, path], [('file-id', file_id)])
311
 
            meta_modified = (kind=='file' and
 
308
            meta_modified = (kind=='file' and 
312
309
                             new_tree.is_executable(file_id))
313
310
            finish_action(action, file_id, kind, meta_modified, True,
314
311
                          DEVNULL, path)
332
329
                continue
333
330
            old_rev = getattr(old_tree.inventory[ie.file_id], 'revision', None)
334
331
            if new_rev != old_rev:
335
 
                action = Action('modified', [ie.kind,
 
332
                action = Action('modified', [ie.kind, 
336
333
                                             new_tree.id2path(ie.file_id)])
337
334
                action.add_utf8_property('last-changed', ie.revision)
338
335
                action.write(self.to_file)
350
347
        object.__init__(self)
351
348
        self.from_file = iter(from_file)
352
349
        self._next_line = None
353
 
 
 
350
        
354
351
        self.info = self._get_info()
355
352
        # We put the actual inventory ids in the footer, so that the patch
356
353
        # is easier to read for humans.
461
458
        else:
462
459
            # What do we do with a key we don't recognize
463
460
            raise errors.MalformedHeader('Unknown Key: "%s"' % key)
464
 
 
 
461
    
465
462
    def _read_many(self, indent):
466
463
        """If a line ends with no entry, that means that it should be
467
464
        followed with multiple lines of values.
504
501
            elif line.startswith('... '):
505
502
                action += line[len('... '):-1].decode('utf-8')
506
503
 
507
 
            if (self._next_line is not None and
 
504
            if (self._next_line is not None and 
508
505
                self._next_line.startswith('===')):
509
506
                return action, lines, True
510
507
            elif self._next_line is None or self._next_line.startswith('#'):
516
513
                lines.append(line)
517
514
 
518
515
        return action, lines, False
519
 
 
 
516
            
520
517
    def _read_patches(self):
521
518
        do_continue = True
522
519
        revision_actions = []
524
521
            action, lines, do_continue = self._read_one_patch()
525
522
            if action is not None:
526
523
                revision_actions.append((action, lines))
527
 
        if self.info.revisions[-1].tree_actions is not None:
528
 
            raise AssertionError()
 
524
        assert self.info.revisions[-1].tree_actions is None
529
525
        self.info.revisions[-1].tree_actions = revision_actions
530
526
 
531
527
    def _read_footer(self):