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

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/shelf.py
19
19
import errno
20
20
import re
21
21
 
22
 
from . import errors
23
 
from .lazy_import import lazy_import
 
22
from bzrlib.lazy_import import lazy_import
24
23
lazy_import(globals(), """
25
 
from breezy import (
 
24
from bzrlib import (
26
25
    bencode,
 
26
    errors,
27
27
    merge,
28
28
    merge3,
 
29
    pack,
29
30
    transform,
30
31
)
31
 
from breezy.bzr import (
32
 
    pack,
33
 
    )
34
32
""")
35
33
 
36
34
 
37
 
class ShelfCorrupt(errors.BzrError):
38
 
 
39
 
    _fmt = "Shelf corrupt."
40
 
 
41
 
 
42
 
class NoSuchShelfId(errors.BzrError):
43
 
 
44
 
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
45
 
 
46
 
    def __init__(self, shelf_id):
47
 
        errors.BzrError.__init__(self, shelf_id=shelf_id)
48
 
 
49
 
 
50
 
class InvalidShelfId(errors.BzrError):
51
 
 
52
 
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
53
 
 
54
 
    def __init__(self, invalid_id):
55
 
        errors.BzrError.__init__(self, invalid_id=invalid_id)
56
 
 
57
 
 
58
35
class ShelfCreator(object):
59
36
    """Create a transform to shelve objects and its inverse."""
60
37
 
125
102
                if kind[0] != kind [1]:
126
103
                    yield ('change kind', file_id, kind[0], kind[1], paths[0])
127
104
                elif kind[0] == 'symlink':
128
 
                    t_target = self.target_tree.get_symlink_target(
129
 
                            paths[0], file_id)
130
 
                    w_target = self.work_tree.get_symlink_target(
131
 
                            paths[1], file_id)
 
105
                    t_target = self.target_tree.get_symlink_target(file_id)
 
106
                    w_target = self.work_tree.get_symlink_target(file_id)
132
107
                    yield ('modify target', file_id, paths[0], t_target,
133
108
                            w_target)
134
109
                elif changed:
180
155
        :param new_target: The target that the symlink should have due
181
156
            to shelving.
182
157
        """
183
 
        new_path = self.target_tree.id2path(file_id)
184
 
        new_target = self.target_tree.get_symlink_target(new_path, file_id)
 
158
        new_target = self.target_tree.get_symlink_target(file_id)
185
159
        w_trans_id = self.work_transform.trans_id_file_id(file_id)
186
160
        self.work_transform.delete_contents(w_trans_id)
187
161
        self.work_transform.create_symlink(new_target, w_trans_id)
188
162
 
189
 
        old_path = self.work_tree.id2path(file_id)
190
 
        old_target = self.work_tree.get_symlink_target(old_path, file_id)
 
163
        old_target = self.work_tree.get_symlink_target(file_id)
191
164
        s_trans_id = self.shelf_transform.trans_id_file_id(file_id)
192
165
        self.shelf_transform.delete_contents(s_trans_id)
193
166
        self.shelf_transform.create_symlink(old_target, s_trans_id)
211
184
    def _content_from_tree(tt, tree, file_id):
212
185
        trans_id = tt.trans_id_file_id(file_id)
213
186
        tt.delete_contents(trans_id)
214
 
        transform.create_from_tree(tt, trans_id, tree, tree.id2path(file_id),
215
 
                                   file_id)
 
187
        transform.create_from_tree(tt, trans_id, tree, file_id)
216
188
 
217
189
    def shelve_content_change(self, file_id):
218
190
        """Shelve a kind change or binary file content change.
268
240
                if kind is None:
269
241
                    to_transform.create_file('', s_trans_id)
270
242
                else:
271
 
                    transform.create_from_tree(
272
 
                            to_transform, s_trans_id, tree,
273
 
                            tree.id2path(file_id), file_id)
 
243
                    transform.create_from_tree(to_transform, s_trans_id,
 
244
                                               tree, file_id)
274
245
        if version:
275
246
            to_transform.version_file(file_id, s_trans_id)
276
247
 
277
248
    def _inverse_lines(self, new_lines, file_id):
278
249
        """Produce a version with only those changes removed from new_lines."""
279
 
        target_path = self.target_tree.id2path(file_id)
280
 
        target_lines = self.target_tree.get_file_lines(target_path, file_id)
281
 
        work_path = self.work_tree.id2path(file_id)
282
 
        work_lines = self.work_tree.get_file_lines(work_path, file_id)
 
250
        target_lines = self.target_tree.get_file_lines(file_id)
 
251
        work_lines = self.work_tree.get_file_lines(file_id)
283
252
        return merge3.Merge3(new_lines, target_lines, work_lines).merge_lines()
284
253
 
285
254
    def finalize(self):
293
262
 
294
263
    @staticmethod
295
264
    def metadata_record(serializer, revision_id, message=None):
296
 
        metadata = {b'revision_id': revision_id}
 
265
        metadata = {'revision_id': revision_id}
297
266
        if message is not None:
298
 
            metadata[b'message'] = message.encode('utf-8')
 
267
            metadata['message'] = message.encode('utf-8')
299
268
        return serializer.bytes_record(
300
269
            bencode.bencode(metadata), (('metadata',),))
301
270
 
345
314
 
346
315
    @staticmethod
347
316
    def parse_metadata(records):
348
 
        names, metadata_bytes = next(records)
 
317
        names, metadata_bytes = records.next()
349
318
        if names[0] != ('metadata',):
350
 
            raise ShelfCorrupt
 
319
            raise errors.ShelfCorrupt
351
320
        metadata = bencode.bdecode(metadata_bytes)
352
321
        message = metadata.get('message')
353
322
        if message is not None:
373
342
        tt.deserialize(records)
374
343
        return klass(tree, base_tree, tt, metadata.get('message'))
375
344
 
376
 
    def make_merger(self):
 
345
    def make_merger(self, task=None):
377
346
        """Return a merger that can unshelve the changes."""
378
347
        target_tree = self.transform.get_preview_tree()
379
348
        merger = merge.Merger.from_uncommitted(self.tree, target_tree,
380
 
            self.base_tree)
 
349
            task, self.base_tree)
381
350
        merger.merge_type = merge.Merge3Merger
382
351
        return merger
383
352
 
435
404
        filename = self.get_shelf_filename(shelf_id)
436
405
        try:
437
406
            return open(self.transport.local_abspath(filename), 'rb')
438
 
        except IOError as e:
 
407
        except IOError, e:
439
408
            if e.errno != errno.ENOENT:
440
409
                raise
441
 
            raise NoSuchShelfId(shelf_id)
 
410
            from bzrlib import errors
 
411
            raise errors.NoSuchShelfId(shelf_id)
442
412
 
443
413
    def get_unshelver(self, shelf_id):
444
414
        """Return an unshelver for a given shelf_id.
470
440
 
471
441
    def active_shelves(self):
472
442
        """Return a list of shelved changes."""
473
 
        active = sorted(self.get_shelf_ids(self.transport.list_dir('.')))
 
443
        active = self.get_shelf_ids(self.transport.list_dir('.'))
 
444
        active.sort()
474
445
        return active
475
446
 
476
447
    def last_shelf(self):