~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-12 10:09:27 UTC
  • mfrom: (1845.1.3 bzr.mbp.hashcache)
  • Revision ID: pqm@pqm.ubuntu.com-20060712100927-6af9cbe9c9e6af3b
(mbp) hashcache fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2004 Aaron Bentley <aaron.bentley@utoronto.ca>
2
 
#
3
 
#    This program is free software; you can redistribute it and/or modify
4
 
#    it under the terms of the GNU General Public License as published by
5
 
#    the Free Software Foundation; either version 2 of the License, or
6
 
#    (at your option) any later version.
7
 
#
8
 
#    This program is distributed in the hope that it will be useful,
9
 
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
#    GNU General Public License for more details.
12
 
#
13
 
#    You should have received a copy of the GNU General Public License
14
 
#    along with this program; if not, write to the Free Software
15
 
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
import os.path
17
 
import errno
18
 
import patch
19
 
import stat
20
 
from bzrlib.trace import mutter
21
 
 
22
 
# XXX: mbp: I'm not totally convinced that we should handle conflicts
23
 
# as part of changeset application, rather than only in the merge
24
 
# operation.
25
 
 
26
 
"""Represent and apply a changeset
27
 
 
28
 
Conflicts in applying a changeset are represented as exceptions.
29
 
"""
30
 
 
31
 
__docformat__ = "restructuredtext"
32
 
 
33
 
NULL_ID = "!NULL"
34
 
 
35
 
class OldFailedTreeOp(Exception):
36
 
    def __init__(self):
37
 
        Exception.__init__(self, "bzr-tree-change contains files from a"
38
 
                           " previous failed merge operation.")
39
 
def invert_dict(dict):
40
 
    newdict = {}
41
 
    for (key,value) in dict.iteritems():
42
 
        newdict[value] = key
43
 
    return newdict
44
 
 
45
 
 
46
 
       
47
 
class ChangeUnixPermissions(object):
48
 
    """This is two-way change, suitable for file modification, creation,
49
 
    deletion"""
50
 
    def __init__(self, old_mode, new_mode):
51
 
        self.old_mode = old_mode
52
 
        self.new_mode = new_mode
53
 
 
54
 
    def apply(self, filename, conflict_handler, reverse=False):
55
 
        if not reverse:
56
 
            from_mode = self.old_mode
57
 
            to_mode = self.new_mode
58
 
        else:
59
 
            from_mode = self.new_mode
60
 
            to_mode = self.old_mode
61
 
        try:
62
 
            current_mode = os.stat(filename).st_mode &0777
63
 
        except OSError, e:
64
 
            if e.errno == errno.ENOENT:
65
 
                if conflict_handler.missing_for_chmod(filename) == "skip":
66
 
                    return
67
 
                else:
68
 
                    current_mode = from_mode
69
 
 
70
 
        if from_mode is not None and current_mode != from_mode:
71
 
            if conflict_handler.wrong_old_perms(filename, from_mode, 
72
 
                                                current_mode) != "continue":
73
 
                return
74
 
 
75
 
        if to_mode is not None:
76
 
            try:
77
 
                os.chmod(filename, to_mode)
78
 
            except IOError, e:
79
 
                if e.errno == errno.ENOENT:
80
 
                    conflict_handler.missing_for_chmod(filename)
81
 
 
82
 
    def __eq__(self, other):
83
 
        if not isinstance(other, ChangeUnixPermissions):
84
 
            return False
85
 
        elif self.old_mode != other.old_mode:
86
 
            return False
87
 
        elif self.new_mode != other.new_mode:
88
 
            return False
89
 
        else:
90
 
            return True
91
 
 
92
 
    def __ne__(self, other):
93
 
        return not (self == other)
94
 
 
95
 
def dir_create(filename, conflict_handler, reverse):
96
 
    """Creates the directory, or deletes it if reverse is true.  Intended to be
97
 
    used with ReplaceContents.
98
 
 
99
 
    :param filename: The name of the directory to create
100
 
    :type filename: str
101
 
    :param reverse: If true, delete the directory, instead
102
 
    :type reverse: bool
103
 
    """
104
 
    if not reverse:
105
 
        try:
106
 
            os.mkdir(filename)
107
 
        except OSError, e:
108
 
            if e.errno != errno.EEXIST:
109
 
                raise
110
 
            if conflict_handler.dir_exists(filename) == "continue":
111
 
                os.mkdir(filename)
112
 
        except IOError, e:
113
 
            if e.errno == errno.ENOENT:
114
 
                if conflict_handler.missing_parent(filename)=="continue":
115
 
                    file(filename, "wb").write(self.contents)
116
 
    else:
117
 
        try:
118
 
            os.rmdir(filename)
119
 
        except OSError, e:
120
 
            if e.errno != 39:
121
 
                raise
122
 
            if conflict_handler.rmdir_non_empty(filename) == "skip":
123
 
                return
124
 
            os.rmdir(filename)
125
 
 
126
 
                
127
 
            
128
 
 
129
 
class SymlinkCreate(object):
130
 
    """Creates or deletes a symlink (for use with ReplaceContents)"""
131
 
    def __init__(self, contents):
132
 
        """Constructor.
133
 
 
134
 
        :param contents: The filename of the target the symlink should point to
135
 
        :type contents: str
136
 
        """
137
 
        self.target = contents
138
 
 
139
 
    def __call__(self, filename, conflict_handler, reverse):
140
 
        """Creates or destroys the symlink.
141
 
 
142
 
        :param filename: The name of the symlink to create
143
 
        :type filename: str
144
 
        """
145
 
        if reverse:
146
 
            assert(os.readlink(filename) == self.target)
147
 
            os.unlink(filename)
148
 
        else:
149
 
            try:
150
 
                os.symlink(self.target, filename)
151
 
            except OSError, e:
152
 
                if e.errno != errno.EEXIST:
153
 
                    raise
154
 
                if conflict_handler.link_name_exists(filename) == "continue":
155
 
                    os.symlink(self.target, filename)
156
 
 
157
 
    def __eq__(self, other):
158
 
        if not isinstance(other, SymlinkCreate):
159
 
            return False
160
 
        elif self.target != other.target:
161
 
            return False
162
 
        else:
163
 
            return True
164
 
 
165
 
    def __ne__(self, other):
166
 
        return not (self == other)
167
 
 
168
 
class FileCreate(object):
169
 
    """Create or delete a file (for use with ReplaceContents)"""
170
 
    def __init__(self, contents):
171
 
        """Constructor
172
 
 
173
 
        :param contents: The contents of the file to write
174
 
        :type contents: str
175
 
        """
176
 
        self.contents = contents
177
 
 
178
 
    def __repr__(self):
179
 
        return "FileCreate(%i b)" % len(self.contents)
180
 
 
181
 
    def __eq__(self, other):
182
 
        if not isinstance(other, FileCreate):
183
 
            return False
184
 
        elif self.contents != other.contents:
185
 
            return False
186
 
        else:
187
 
            return True
188
 
 
189
 
    def __ne__(self, other):
190
 
        return not (self == other)
191
 
 
192
 
    def __call__(self, filename, conflict_handler, reverse):
193
 
        """Create or delete a file
194
 
 
195
 
        :param filename: The name of the file to create
196
 
        :type filename: str
197
 
        :param reverse: Delete the file instead of creating it
198
 
        :type reverse: bool
199
 
        """
200
 
        if not reverse:
201
 
            try:
202
 
                file(filename, "wb").write(self.contents)
203
 
            except IOError, e:
204
 
                if e.errno == errno.ENOENT:
205
 
                    if conflict_handler.missing_parent(filename)=="continue":
206
 
                        file(filename, "wb").write(self.contents)
207
 
                else:
208
 
                    raise
209
 
 
210
 
        else:
211
 
            try:
212
 
                if (file(filename, "rb").read() != self.contents):
213
 
                    direction = conflict_handler.wrong_old_contents(filename,
214
 
                                                                    self.contents)
215
 
                    if  direction != "continue":
216
 
                        return
217
 
                os.unlink(filename)
218
 
            except IOError, e:
219
 
                if e.errno != errno.ENOENT:
220
 
                    raise
221
 
                if conflict_handler.missing_for_rm(filename, undo) == "skip":
222
 
                    return
223
 
 
224
 
                    
225
 
 
226
 
def reversed(sequence):
227
 
    max = len(sequence) - 1
228
 
    for i in range(len(sequence)):
229
 
        yield sequence[max - i]
230
 
 
231
 
class ReplaceContents(object):
232
 
    """A contents-replacement framework.  It allows a file/directory/symlink to
233
 
    be created, deleted, or replaced with another file/directory/symlink.
234
 
    Arguments must be callable with (filename, reverse).
235
 
    """
236
 
    def __init__(self, old_contents, new_contents):
237
 
        """Constructor.
238
 
 
239
 
        :param old_contents: The change to reverse apply (e.g. a deletion), \
240
 
        when going forwards.
241
 
        :type old_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
242
 
        NoneType, etc.
243
 
        :param new_contents: The second change to apply (e.g. a creation), \
244
 
        when going forwards.
245
 
        :type new_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
246
 
        NoneType, etc.
247
 
        """
248
 
        self.old_contents=old_contents
249
 
        self.new_contents=new_contents
250
 
 
251
 
    def __repr__(self):
252
 
        return "ReplaceContents(%r -> %r)" % (self.old_contents,
253
 
                                              self.new_contents)
254
 
 
255
 
    def __eq__(self, other):
256
 
        if not isinstance(other, ReplaceContents):
257
 
            return False
258
 
        elif self.old_contents != other.old_contents:
259
 
            return False
260
 
        elif self.new_contents != other.new_contents:
261
 
            return False
262
 
        else:
263
 
            return True
264
 
    def __ne__(self, other):
265
 
        return not (self == other)
266
 
 
267
 
    def apply(self, filename, conflict_handler, reverse=False):
268
 
        """Applies the FileReplacement to the specified filename
269
 
 
270
 
        :param filename: The name of the file to apply changes to
271
 
        :type filename: str
272
 
        :param reverse: If true, apply the change in reverse
273
 
        :type reverse: bool
274
 
        """
275
 
        if not reverse:
276
 
            undo = self.old_contents
277
 
            perform = self.new_contents
278
 
        else:
279
 
            undo = self.new_contents
280
 
            perform = self.old_contents
281
 
        mode = None
282
 
        if undo is not None:
283
 
            try:
284
 
                mode = os.lstat(filename).st_mode
285
 
                if stat.S_ISLNK(mode):
286
 
                    mode = None
287
 
            except OSError, e:
288
 
                if e.errno != errno.ENOENT:
289
 
                    raise
290
 
                if conflict_handler.missing_for_rm(filename, undo) == "skip":
291
 
                    return
292
 
            undo(filename, conflict_handler, reverse=True)
293
 
        if perform is not None:
294
 
            perform(filename, conflict_handler, reverse=False)
295
 
            if mode is not None:
296
 
                os.chmod(filename, mode)
297
 
 
298
 
class ApplySequence(object):
299
 
    def __init__(self, changes=None):
300
 
        self.changes = []
301
 
        if changes is not None:
302
 
            self.changes.extend(changes)
303
 
 
304
 
    def __eq__(self, other):
305
 
        if not isinstance(other, ApplySequence):
306
 
            return False
307
 
        elif len(other.changes) != len(self.changes):
308
 
            return False
309
 
        else:
310
 
            for i in range(len(self.changes)):
311
 
                if self.changes[i] != other.changes[i]:
312
 
                    return False
313
 
            return True
314
 
 
315
 
    def __ne__(self, other):
316
 
        return not (self == other)
317
 
 
318
 
    
319
 
    def apply(self, filename, conflict_handler, reverse=False):
320
 
        if not reverse:
321
 
            iter = self.changes
322
 
        else:
323
 
            iter = reversed(self.changes)
324
 
        for change in iter:
325
 
            change.apply(filename, conflict_handler, reverse)
326
 
 
327
 
 
328
 
class Diff3Merge(object):
329
 
    def __init__(self, file_id, base, other):
330
 
        self.file_id = file_id
331
 
        self.base = base
332
 
        self.other = other
333
 
 
334
 
    def __eq__(self, other):
335
 
        if not isinstance(other, Diff3Merge):
336
 
            return False
337
 
        return (self.base == other.base and 
338
 
                self.other == other.other and self.file_id == other.file_id)
339
 
 
340
 
    def __ne__(self, other):
341
 
        return not (self == other)
342
 
 
343
 
    def apply(self, filename, conflict_handler, reverse=False):
344
 
        new_file = filename+".new"
345
 
        base_file = self.base.readonly_path(self.file_id)
346
 
        other_file = self.other.readonly_path(self.file_id)
347
 
        if not reverse:
348
 
            base = base_file
349
 
            other = other_file
350
 
        else:
351
 
            base = other_file
352
 
            other = base_file
353
 
        status = patch.diff3(new_file, filename, base, other)
354
 
        if status == 0:
355
 
            os.chmod(new_file, os.stat(filename).st_mode)
356
 
            os.rename(new_file, filename)
357
 
            return
358
 
        else:
359
 
            assert(status == 1)
360
 
            def get_lines(filename):
361
 
                my_file = file(base, "rb")
362
 
                lines = my_file.readlines()
363
 
                my_file.close()
364
 
            base_lines = get_lines(base)
365
 
            other_lines = get_lines(other)
366
 
            conflict_handler.merge_conflict(new_file, filename, base_lines, 
367
 
                                            other_lines)
368
 
 
369
 
 
370
 
def CreateDir():
371
 
    """Convenience function to create a directory.
372
 
 
373
 
    :return: A ReplaceContents that will create a directory
374
 
    :rtype: `ReplaceContents`
375
 
    """
376
 
    return ReplaceContents(None, dir_create)
377
 
 
378
 
def DeleteDir():
379
 
    """Convenience function to delete a directory.
380
 
 
381
 
    :return: A ReplaceContents that will delete a directory
382
 
    :rtype: `ReplaceContents`
383
 
    """
384
 
    return ReplaceContents(dir_create, None)
385
 
 
386
 
def CreateFile(contents):
387
 
    """Convenience fucntion to create a file.
388
 
    
389
 
    :param contents: The contents of the file to create 
390
 
    :type contents: str
391
 
    :return: A ReplaceContents that will create a file 
392
 
    :rtype: `ReplaceContents`
393
 
    """
394
 
    return ReplaceContents(None, FileCreate(contents))
395
 
 
396
 
def DeleteFile(contents):
397
 
    """Convenience fucntion to delete a file.
398
 
    
399
 
    :param contents: The contents of the file to delete
400
 
    :type contents: str
401
 
    :return: A ReplaceContents that will delete a file 
402
 
    :rtype: `ReplaceContents`
403
 
    """
404
 
    return ReplaceContents(FileCreate(contents), None)
405
 
 
406
 
def ReplaceFileContents(old_contents, new_contents):
407
 
    """Convenience fucntion to replace the contents of a file.
408
 
    
409
 
    :param old_contents: The contents of the file to replace 
410
 
    :type old_contents: str
411
 
    :param new_contents: The contents to replace the file with
412
 
    :type new_contents: str
413
 
    :return: A ReplaceContents that will replace the contents of a file a file 
414
 
    :rtype: `ReplaceContents`
415
 
    """
416
 
    return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
417
 
 
418
 
def CreateSymlink(target):
419
 
    """Convenience fucntion to create a symlink.
420
 
    
421
 
    :param target: The path the link should point to
422
 
    :type target: str
423
 
    :return: A ReplaceContents that will delete a file 
424
 
    :rtype: `ReplaceContents`
425
 
    """
426
 
    return ReplaceContents(None, SymlinkCreate(target))
427
 
 
428
 
def DeleteSymlink(target):
429
 
    """Convenience fucntion to delete a symlink.
430
 
    
431
 
    :param target: The path the link should point to
432
 
    :type target: str
433
 
    :return: A ReplaceContents that will delete a file 
434
 
    :rtype: `ReplaceContents`
435
 
    """
436
 
    return ReplaceContents(SymlinkCreate(target), None)
437
 
 
438
 
def ChangeTarget(old_target, new_target):
439
 
    """Convenience fucntion to change the target of a symlink.
440
 
    
441
 
    :param old_target: The current link target
442
 
    :type old_target: str
443
 
    :param new_target: The new link target to use
444
 
    :type new_target: str
445
 
    :return: A ReplaceContents that will delete a file 
446
 
    :rtype: `ReplaceContents`
447
 
    """
448
 
    return ReplaceContents(SymlinkCreate(old_target), SymlinkCreate(new_target))
449
 
 
450
 
 
451
 
class InvalidEntry(Exception):
452
 
    """Raise when a ChangesetEntry is invalid in some way"""
453
 
    def __init__(self, entry, problem):
454
 
        """Constructor.
455
 
 
456
 
        :param entry: The invalid ChangesetEntry
457
 
        :type entry: `ChangesetEntry`
458
 
        :param problem: The problem with the entry
459
 
        :type problem: str
460
 
        """
461
 
        msg = "Changeset entry for %s (%s) is invalid.\n%s" % (entry.id, 
462
 
                                                               entry.path, 
463
 
                                                               problem)
464
 
        Exception.__init__(self, msg)
465
 
        self.entry = entry
466
 
 
467
 
 
468
 
class SourceRootHasName(InvalidEntry):
469
 
    """This changeset entry has a name other than "", but its parent is !NULL"""
470
 
    def __init__(self, entry, name):
471
 
        """Constructor.
472
 
 
473
 
        :param entry: The invalid ChangesetEntry
474
 
        :type entry: `ChangesetEntry`
475
 
        :param name: The name of the entry
476
 
        :type name: str
477
 
        """
478
 
        msg = 'Child of !NULL is named "%s", not "./.".' % name
479
 
        InvalidEntry.__init__(self, entry, msg)
480
 
 
481
 
class NullIDAssigned(InvalidEntry):
482
 
    """The id !NULL was assigned to a real entry"""
483
 
    def __init__(self, entry):
484
 
        """Constructor.
485
 
 
486
 
        :param entry: The invalid ChangesetEntry
487
 
        :type entry: `ChangesetEntry`
488
 
        """
489
 
        msg = '"!NULL" id assigned to a file "%s".' % entry.path
490
 
        InvalidEntry.__init__(self, entry, msg)
491
 
 
492
 
class ParentIDIsSelf(InvalidEntry):
493
 
    """An entry is marked as its own parent"""
494
 
    def __init__(self, entry):
495
 
        """Constructor.
496
 
 
497
 
        :param entry: The invalid ChangesetEntry
498
 
        :type entry: `ChangesetEntry`
499
 
        """
500
 
        msg = 'file %s has "%s" id for both self id and parent id.' % \
501
 
            (entry.path, entry.id)
502
 
        InvalidEntry.__init__(self, entry, msg)
503
 
 
504
 
class ChangesetEntry(object):
505
 
    """An entry the changeset"""
506
 
    def __init__(self, id, parent, path):
507
 
        """Constructor. Sets parent and name assuming it was not
508
 
        renamed/created/deleted.
509
 
        :param id: The id associated with the entry
510
 
        :param parent: The id of the parent of this entry (or !NULL if no
511
 
        parent)
512
 
        :param path: The file path relative to the tree root of this entry
513
 
        """
514
 
        self.id = id
515
 
        self.path = path 
516
 
        self.new_path = path
517
 
        self.parent = parent
518
 
        self.new_parent = parent
519
 
        self.contents_change = None
520
 
        self.metadata_change = None
521
 
        if parent == NULL_ID and path !='./.':
522
 
            raise SourceRootHasName(self, path)
523
 
        if self.id == NULL_ID:
524
 
            raise NullIDAssigned(self)
525
 
        if self.id  == self.parent:
526
 
            raise ParentIDIsSelf(self)
527
 
 
528
 
    def __str__(self):
529
 
        return "ChangesetEntry(%s)" % self.id
530
 
 
531
 
    def __get_dir(self):
532
 
        if self.path is None:
533
 
            return None
534
 
        return os.path.dirname(self.path)
535
 
 
536
 
    def __set_dir(self, dir):
537
 
        self.path = os.path.join(dir, os.path.basename(self.path))
538
 
 
539
 
    dir = property(__get_dir, __set_dir)
540
 
    
541
 
    def __get_name(self):
542
 
        if self.path is None:
543
 
            return None
544
 
        return os.path.basename(self.path)
545
 
 
546
 
    def __set_name(self, name):
547
 
        self.path = os.path.join(os.path.dirname(self.path), name)
548
 
 
549
 
    name = property(__get_name, __set_name)
550
 
 
551
 
    def __get_new_dir(self):
552
 
        if self.new_path is None:
553
 
            return None
554
 
        return os.path.dirname(self.new_path)
555
 
 
556
 
    def __set_new_dir(self, dir):
557
 
        self.new_path = os.path.join(dir, os.path.basename(self.new_path))
558
 
 
559
 
    new_dir = property(__get_new_dir, __set_new_dir)
560
 
 
561
 
    def __get_new_name(self):
562
 
        if self.new_path is None:
563
 
            return None
564
 
        return os.path.basename(self.new_path)
565
 
 
566
 
    def __set_new_name(self, name):
567
 
        self.new_path = os.path.join(os.path.dirname(self.new_path), name)
568
 
 
569
 
    new_name = property(__get_new_name, __set_new_name)
570
 
 
571
 
    def needs_rename(self):
572
 
        """Determines whether the entry requires renaming.
573
 
 
574
 
        :rtype: bool
575
 
        """
576
 
 
577
 
        return (self.parent != self.new_parent or self.name != self.new_name)
578
 
 
579
 
    def is_deletion(self, reverse):
580
 
        """Return true if applying the entry would delete a file/directory.
581
 
 
582
 
        :param reverse: if true, the changeset is being applied in reverse
583
 
        :rtype: bool
584
 
        """
585
 
        return ((self.new_parent is None and not reverse) or 
586
 
                (self.parent is None and reverse))
587
 
 
588
 
    def is_creation(self, reverse):
589
 
        """Return true if applying the entry would create a file/directory.
590
 
 
591
 
        :param reverse: if true, the changeset is being applied in reverse
592
 
        :rtype: bool
593
 
        """
594
 
        return ((self.parent is None and not reverse) or 
595
 
                (self.new_parent is None and reverse))
596
 
 
597
 
    def is_creation_or_deletion(self):
598
 
        """Return true if applying the entry would create or delete a 
599
 
        file/directory.
600
 
 
601
 
        :rtype: bool
602
 
        """
603
 
        return self.parent is None or self.new_parent is None
604
 
 
605
 
    def get_cset_path(self, mod=False):
606
 
        """Determine the path of the entry according to the changeset.
607
 
 
608
 
        :param changeset: The changeset to derive the path from
609
 
        :type changeset: `Changeset`
610
 
        :param mod: If true, generate the MOD path.  Otherwise, generate the \
611
 
        ORIG path.
612
 
        :return: the path of the entry, or None if it did not exist in the \
613
 
        requested tree.
614
 
        :rtype: str or NoneType
615
 
        """
616
 
        if mod:
617
 
            if self.new_parent == NULL_ID:
618
 
                return "./."
619
 
            elif self.new_parent is None:
620
 
                return None
621
 
            return self.new_path
622
 
        else:
623
 
            if self.parent == NULL_ID:
624
 
                return "./."
625
 
            elif self.parent is None:
626
 
                return None
627
 
            return self.path
628
 
 
629
 
    def summarize_name(self, reverse=False):
630
 
        """Produce a one-line summary of the filename.  Indicates renames as
631
 
        old => new, indicates creation as None => new, indicates deletion as
632
 
        old => None.
633
 
 
634
 
        :param changeset: The changeset to get paths from
635
 
        :type changeset: `Changeset`
636
 
        :param reverse: If true, reverse the names in the output
637
 
        :type reverse: bool
638
 
        :rtype: str
639
 
        """
640
 
        orig_path = self.get_cset_path(False)
641
 
        mod_path = self.get_cset_path(True)
642
 
        if orig_path is not None:
643
 
            orig_path = orig_path[2:]
644
 
        if mod_path is not None:
645
 
            mod_path = mod_path[2:]
646
 
        if orig_path == mod_path:
647
 
            return orig_path
648
 
        else:
649
 
            if not reverse:
650
 
                return "%s => %s" % (orig_path, mod_path)
651
 
            else:
652
 
                return "%s => %s" % (mod_path, orig_path)
653
 
 
654
 
 
655
 
    def get_new_path(self, id_map, changeset, reverse=False):
656
 
        """Determine the full pathname to rename to
657
 
 
658
 
        :param id_map: The map of ids to filenames for the tree
659
 
        :type id_map: Dictionary
660
 
        :param changeset: The changeset to get data from
661
 
        :type changeset: `Changeset`
662
 
        :param reverse: If true, we're applying the changeset in reverse
663
 
        :type reverse: bool
664
 
        :rtype: str
665
 
        """
666
 
        mutter("Finding new path for %s" % self.summarize_name())
667
 
        if reverse:
668
 
            parent = self.parent
669
 
            to_dir = self.dir
670
 
            from_dir = self.new_dir
671
 
            to_name = self.name
672
 
            from_name = self.new_name
673
 
        else:
674
 
            parent = self.new_parent
675
 
            to_dir = self.new_dir
676
 
            from_dir = self.dir
677
 
            to_name = self.new_name
678
 
            from_name = self.name
679
 
 
680
 
        if to_name is None:
681
 
            return None
682
 
 
683
 
        if parent == NULL_ID or parent is None:
684
 
            if to_name != '.':
685
 
                raise SourceRootHasName(self, to_name)
686
 
            else:
687
 
                return '.'
688
 
        if from_dir == to_dir:
689
 
            dir = os.path.dirname(id_map[self.id])
690
 
        else:
691
 
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
692
 
            parent_entry = changeset.entries[parent]
693
 
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
694
 
        if from_name == to_name:
695
 
            name = os.path.basename(id_map[self.id])
696
 
        else:
697
 
            name = to_name
698
 
            assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
699
 
        return os.path.join(dir, name)
700
 
 
701
 
    def is_boring(self):
702
 
        """Determines whether the entry does nothing
703
 
        
704
 
        :return: True if the entry does no renames or content changes
705
 
        :rtype: bool
706
 
        """
707
 
        if self.contents_change is not None:
708
 
            return False
709
 
        elif self.metadata_change is not None:
710
 
            return False
711
 
        elif self.parent != self.new_parent:
712
 
            return False
713
 
        elif self.name != self.new_name:
714
 
            return False
715
 
        else:
716
 
            return True
717
 
 
718
 
    def apply(self, filename, conflict_handler, reverse=False):
719
 
        """Applies the file content and/or metadata changes.
720
 
 
721
 
        :param filename: the filename of the entry
722
 
        :type filename: str
723
 
        :param reverse: If true, apply the changes in reverse
724
 
        :type reverse: bool
725
 
        """
726
 
        if self.is_deletion(reverse) and self.metadata_change is not None:
727
 
            self.metadata_change.apply(filename, conflict_handler, reverse)
728
 
        if self.contents_change is not None:
729
 
            self.contents_change.apply(filename, conflict_handler, reverse)
730
 
        if not self.is_deletion(reverse) and self.metadata_change is not None:
731
 
            self.metadata_change.apply(filename, conflict_handler, reverse)
732
 
 
733
 
class IDPresent(Exception):
734
 
    def __init__(self, id):
735
 
        msg = "Cannot add entry because that id has already been used:\n%s" %\
736
 
            id
737
 
        Exception.__init__(self, msg)
738
 
        self.id = id
739
 
 
740
 
class Changeset(object):
741
 
    """A set of changes to apply"""
742
 
    def __init__(self):
743
 
        self.entries = {}
744
 
 
745
 
    def add_entry(self, entry):
746
 
        """Add an entry to the list of entries"""
747
 
        if self.entries.has_key(entry.id):
748
 
            raise IDPresent(entry.id)
749
 
        self.entries[entry.id] = entry
750
 
 
751
 
def my_sort(sequence, key, reverse=False):
752
 
    """A sort function that supports supplying a key for comparison
753
 
    
754
 
    :param sequence: The sequence to sort
755
 
    :param key: A callable object that returns the values to be compared
756
 
    :param reverse: If true, sort in reverse order
757
 
    :type reverse: bool
758
 
    """
759
 
    def cmp_by_key(entry_a, entry_b):
760
 
        if reverse:
761
 
            tmp=entry_a
762
 
            entry_a = entry_b
763
 
            entry_b = tmp
764
 
        return cmp(key(entry_a), key(entry_b))
765
 
    sequence.sort(cmp_by_key)
766
 
 
767
 
def get_rename_entries(changeset, inventory, reverse):
768
 
    """Return a list of entries that will be renamed.  Entries are sorted from
769
 
    longest to shortest source path and from shortest to longest target path.
770
 
 
771
 
    :param changeset: The changeset to look in
772
 
    :type changeset: `Changeset`
773
 
    :param inventory: The source of current tree paths for the given ids
774
 
    :type inventory: Dictionary
775
 
    :param reverse: If true, the changeset is being applied in reverse
776
 
    :type reverse: bool
777
 
    :return: source entries and target entries as a tuple
778
 
    :rtype: (List, List)
779
 
    """
780
 
    source_entries = [x for x in changeset.entries.itervalues() 
781
 
                      if x.needs_rename()]
782
 
    # these are done from longest path to shortest, to avoid deleting a
783
 
    # parent before its children are deleted/renamed 
784
 
    def longest_to_shortest(entry):
785
 
        path = inventory.get(entry.id)
786
 
        if path is None:
787
 
            return 0
788
 
        else:
789
 
            return len(path)
790
 
    my_sort(source_entries, longest_to_shortest, reverse=True)
791
 
 
792
 
    target_entries = source_entries[:]
793
 
    # These are done from shortest to longest path, to avoid creating a
794
 
    # child before its parent has been created/renamed
795
 
    def shortest_to_longest(entry):
796
 
        path = entry.get_new_path(inventory, changeset, reverse)
797
 
        if path is None:
798
 
            return 0
799
 
        else:
800
 
            return len(path)
801
 
    my_sort(target_entries, shortest_to_longest)
802
 
    return (source_entries, target_entries)
803
 
 
804
 
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir, 
805
 
                          conflict_handler, reverse):
806
 
    """Delete and rename entries as appropriate.  Entries are renamed to temp
807
 
    names.  A map of id -> temp name (or None, for deletions) is returned.
808
 
 
809
 
    :param source_entries: The entries to rename and delete
810
 
    :type source_entries: List of `ChangesetEntry`
811
 
    :param inventory: The map of id -> filename in the current tree
812
 
    :type inventory: Dictionary
813
 
    :param dir: The directory to apply changes to
814
 
    :type dir: str
815
 
    :param reverse: Apply changes in reverse
816
 
    :type reverse: bool
817
 
    :return: a mapping of id to temporary name
818
 
    :rtype: Dictionary
819
 
    """
820
 
    temp_name = {}
821
 
    for i in range(len(source_entries)):
822
 
        entry = source_entries[i]
823
 
        if entry.is_deletion(reverse):
824
 
            path = os.path.join(dir, inventory[entry.id])
825
 
            entry.apply(path, conflict_handler, reverse)
826
 
            temp_name[entry.id] = None
827
 
 
828
 
        else:
829
 
            to_name = os.path.join(temp_dir, str(i))
830
 
            src_path = inventory.get(entry.id)
831
 
            if src_path is not None:
832
 
                src_path = os.path.join(dir, src_path)
833
 
                try:
834
 
                    os.rename(src_path, to_name)
835
 
                    temp_name[entry.id] = to_name
836
 
                except OSError, e:
837
 
                    if e.errno != errno.ENOENT:
838
 
                        raise
839
 
                    if conflict_handler.missing_for_rename(src_path) == "skip":
840
 
                        continue
841
 
 
842
 
    return temp_name
843
 
 
844
 
 
845
 
def rename_to_new_create(changed_inventory, target_entries, inventory, 
846
 
                         changeset, dir, conflict_handler, reverse):
847
 
    """Rename entries with temp names to their final names, create new files.
848
 
 
849
 
    :param changed_inventory: A mapping of id to temporary name
850
 
    :type changed_inventory: Dictionary
851
 
    :param target_entries: The entries to apply changes to
852
 
    :type target_entries: List of `ChangesetEntry`
853
 
    :param changeset: The changeset to apply
854
 
    :type changeset: `Changeset`
855
 
    :param dir: The directory to apply changes to
856
 
    :type dir: str
857
 
    :param reverse: If true, apply changes in reverse
858
 
    :type reverse: bool
859
 
    """
860
 
    for entry in target_entries:
861
 
        new_tree_path = entry.get_new_path(inventory, changeset, reverse)
862
 
        if new_tree_path is None:
863
 
            continue
864
 
        new_path = os.path.join(dir, new_tree_path)
865
 
        old_path = changed_inventory.get(entry.id)
866
 
        if os.path.exists(new_path):
867
 
            if conflict_handler.target_exists(entry, new_path, old_path) == \
868
 
                "skip":
869
 
                continue
870
 
        if entry.is_creation(reverse):
871
 
            entry.apply(new_path, conflict_handler, reverse)
872
 
            changed_inventory[entry.id] = new_tree_path
873
 
        else:
874
 
            if old_path is None:
875
 
                continue
876
 
            try:
877
 
                os.rename(old_path, new_path)
878
 
                changed_inventory[entry.id] = new_tree_path
879
 
            except OSError, e:
880
 
                raise Exception ("%s is missing" % new_path)
881
 
 
882
 
class TargetExists(Exception):
883
 
    def __init__(self, entry, target):
884
 
        msg = "The path %s already exists" % target
885
 
        Exception.__init__(self, msg)
886
 
        self.entry = entry
887
 
        self.target = target
888
 
 
889
 
class RenameConflict(Exception):
890
 
    def __init__(self, id, this_name, base_name, other_name):
891
 
        msg = """Trees all have different names for a file
892
 
 this: %s
893
 
 base: %s
894
 
other: %s
895
 
   id: %s""" % (this_name, base_name, other_name, id)
896
 
        Exception.__init__(self, msg)
897
 
        self.this_name = this_name
898
 
        self.base_name = base_name
899
 
        self_other_name = other_name
900
 
 
901
 
class MoveConflict(Exception):
902
 
    def __init__(self, id, this_parent, base_parent, other_parent):
903
 
        msg = """The file is in different directories in every tree
904
 
 this: %s
905
 
 base: %s
906
 
other: %s
907
 
   id: %s""" % (this_parent, base_parent, other_parent, id)
908
 
        Exception.__init__(self, msg)
909
 
        self.this_parent = this_parent
910
 
        self.base_parent = base_parent
911
 
        self_other_parent = other_parent
912
 
 
913
 
class MergeConflict(Exception):
914
 
    def __init__(self, this_path):
915
 
        Exception.__init__(self, "Conflict applying changes to %s" % this_path)
916
 
        self.this_path = this_path
917
 
 
918
 
class MergePermissionConflict(Exception):
919
 
    def __init__(self, this_path, base_path, other_path):
920
 
        this_perms = os.stat(this_path).st_mode & 0755
921
 
        base_perms = os.stat(base_path).st_mode & 0755
922
 
        other_perms = os.stat(other_path).st_mode & 0755
923
 
        msg = """Conflicting permission for %s
924
 
this: %o
925
 
base: %o
926
 
other: %o
927
 
        """ % (this_path, this_perms, base_perms, other_perms)
928
 
        self.this_path = this_path
929
 
        self.base_path = base_path
930
 
        self.other_path = other_path
931
 
        Exception.__init__(self, msg)
932
 
 
933
 
class WrongOldContents(Exception):
934
 
    def __init__(self, filename):
935
 
        msg = "Contents mismatch deleting %s" % filename
936
 
        self.filename = filename
937
 
        Exception.__init__(self, msg)
938
 
 
939
 
class WrongOldPermissions(Exception):
940
 
    def __init__(self, filename, old_perms, new_perms):
941
 
        msg = "Permission missmatch on %s:\n" \
942
 
        "Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
943
 
        self.filename = filename
944
 
        Exception.__init__(self, msg)
945
 
 
946
 
class RemoveContentsConflict(Exception):
947
 
    def __init__(self, filename):
948
 
        msg = "Conflict deleting %s, which has different contents in BASE"\
949
 
            " and THIS" % filename
950
 
        self.filename = filename
951
 
        Exception.__init__(self, msg)
952
 
 
953
 
class DeletingNonEmptyDirectory(Exception):
954
 
    def __init__(self, filename):
955
 
        msg = "Trying to remove dir %s while it still had files" % filename
956
 
        self.filename = filename
957
 
        Exception.__init__(self, msg)
958
 
 
959
 
 
960
 
class PatchTargetMissing(Exception):
961
 
    def __init__(self, filename):
962
 
        msg = "Attempt to patch %s, which does not exist" % filename
963
 
        Exception.__init__(self, msg)
964
 
        self.filename = filename
965
 
 
966
 
class MissingPermsFile(Exception):
967
 
    def __init__(self, filename):
968
 
        msg = "Attempt to change permissions on  %s, which does not exist" %\
969
 
            filename
970
 
        Exception.__init__(self, msg)
971
 
        self.filename = filename
972
 
 
973
 
class MissingForRm(Exception):
974
 
    def __init__(self, filename):
975
 
        msg = "Attempt to remove missing path %s" % filename
976
 
        Exception.__init__(self, msg)
977
 
        self.filename = filename
978
 
 
979
 
 
980
 
class MissingForRename(Exception):
981
 
    def __init__(self, filename):
982
 
        msg = "Attempt to move missing path %s" % (filename)
983
 
        Exception.__init__(self, msg)
984
 
        self.filename = filename
985
 
 
986
 
class NewContentsConflict(Exception):
987
 
    def __init__(self, filename):
988
 
        msg = "Conflicting contents for new file %s" % (filename)
989
 
        Exception.__init__(self, msg)
990
 
 
991
 
 
992
 
class MissingForMerge(Exception):
993
 
    def __init__(self, filename):
994
 
        msg = "The file %s was modified, but does not exist in this tree"\
995
 
            % (filename)
996
 
        Exception.__init__(self, msg)
997
 
 
998
 
 
999
 
class ExceptionConflictHandler(object):
1000
 
    """Default handler for merge exceptions.
1001
 
 
1002
 
    This throws an error on any kind of conflict.  Conflict handlers can
1003
 
    descend from this class if they have a better way to handle some or
1004
 
    all types of conflict.
1005
 
    """
1006
 
    def __init__(self, dir):
1007
 
        self.dir = dir
1008
 
    
1009
 
    def missing_parent(self, pathname):
1010
 
        parent = os.path.dirname(pathname)
1011
 
        raise Exception("Parent directory missing for %s" % pathname)
1012
 
 
1013
 
    def dir_exists(self, pathname):
1014
 
        raise Exception("Directory already exists for %s" % pathname)
1015
 
 
1016
 
    def failed_hunks(self, pathname):
1017
 
        raise Exception("Failed to apply some hunks for %s" % pathname)
1018
 
 
1019
 
    def target_exists(self, entry, target, old_path):
1020
 
        raise TargetExists(entry, target)
1021
 
 
1022
 
    def rename_conflict(self, id, this_name, base_name, other_name):
1023
 
        raise RenameConflict(id, this_name, base_name, other_name)
1024
 
 
1025
 
    def move_conflict(self, id, this_dir, base_dir, other_dir):
1026
 
        raise MoveConflict(id, this_dir, base_dir, other_dir)
1027
 
 
1028
 
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1029
 
        os.unlink(new_file)
1030
 
        raise MergeConflict(this_path)
1031
 
 
1032
 
    def permission_conflict(self, this_path, base_path, other_path):
1033
 
        raise MergePermissionConflict(this_path, base_path, other_path)
1034
 
 
1035
 
    def wrong_old_contents(self, filename, expected_contents):
1036
 
        raise WrongOldContents(filename)
1037
 
 
1038
 
    def rem_contents_conflict(self, filename, this_contents, base_contents):
1039
 
        raise RemoveContentsConflict(filename)
1040
 
 
1041
 
    def wrong_old_perms(self, filename, old_perms, new_perms):
1042
 
        raise WrongOldPermissions(filename, old_perms, new_perms)
1043
 
 
1044
 
    def rmdir_non_empty(self, filename):
1045
 
        raise DeletingNonEmptyDirectory(filename)
1046
 
 
1047
 
    def link_name_exists(self, filename):
1048
 
        raise TargetExists(filename)
1049
 
 
1050
 
    def patch_target_missing(self, filename, contents):
1051
 
        raise PatchTargetMissing(filename)
1052
 
 
1053
 
    def missing_for_chmod(self, filename):
1054
 
        raise MissingPermsFile(filename)
1055
 
 
1056
 
    def missing_for_rm(self, filename, change):
1057
 
        raise MissingForRm(filename)
1058
 
 
1059
 
    def missing_for_rename(self, filename):
1060
 
        raise MissingForRename(filename)
1061
 
 
1062
 
    def missing_for_merge(self, file_id, other_path):
1063
 
        raise MissingForMerge(other_path)
1064
 
 
1065
 
    def new_contents_conflict(self, filename, other_contents):
1066
 
        raise NewContentsConflict(filename)
1067
 
 
1068
 
    def finalize(self):
1069
 
        pass
1070
 
 
1071
 
def apply_changeset(changeset, inventory, dir, conflict_handler=None, 
1072
 
                    reverse=False):
1073
 
    """Apply a changeset to a directory.
1074
 
 
1075
 
    :param changeset: The changes to perform
1076
 
    :type changeset: `Changeset`
1077
 
    :param inventory: The mapping of id to filename for the directory
1078
 
    :type inventory: Dictionary
1079
 
    :param dir: The path of the directory to apply the changes to
1080
 
    :type dir: str
1081
 
    :param reverse: If true, apply the changes in reverse
1082
 
    :type reverse: bool
1083
 
    :return: The mapping of the changed entries
1084
 
    :rtype: Dictionary
1085
 
    """
1086
 
    if conflict_handler is None:
1087
 
        conflict_handler = ExceptionConflictHandler(dir)
1088
 
    temp_dir = os.path.join(dir, "bzr-tree-change")
 
1
# Copyright (C) 2006 by Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from bzrlib.bundle.serializer import read_bundle
 
18
import bzrlib.errors as errors
 
19
import bzrlib.urlutils
 
20
import bzrlib.transport
 
21
 
 
22
 
 
23
def read_bundle_from_url(url):
 
24
    """Read a bundle from a given URL.
 
25
 
 
26
    :return: A BundleReader, may raise NotABundle if the target 
 
27
            is not a proper bundle.
 
28
    """
 
29
    url, filename = bzrlib.urlutils.split(url, exclude_trailing_slash=False)
 
30
    if not filename:
 
31
        # A path to a directory was passed in
 
32
        # definitely not a bundle
 
33
        raise errors.NotABundle('A directory cannot be a bundle')
 
34
 
 
35
    # All of this must be in the try/except
 
36
    # Some transports cannot detect that we are trying to read a
 
37
    # directory until we actually issue read() on the handle.
1089
38
    try:
1090
 
        os.mkdir(temp_dir)
1091
 
    except OSError, e:
1092
 
        if e.errno == errno.EEXIST:
1093
 
            try:
1094
 
                os.rmdir(temp_dir)
1095
 
            except OSError, e:
1096
 
                if e.errno == errno.ENOTEMPTY:
1097
 
                    raise OldFailedTreeOp()
1098
 
            os.mkdir(temp_dir)
1099
 
        else:
1100
 
            raise
1101
 
    
1102
 
    #apply changes that don't affect filenames
1103
 
    for entry in changeset.entries.itervalues():
1104
 
        if not entry.is_creation_or_deletion():
1105
 
            path = os.path.join(dir, inventory[entry.id])
1106
 
            entry.apply(path, conflict_handler, reverse)
1107
 
 
1108
 
    # Apply renames in stages, to minimize conflicts:
1109
 
    # Only files whose name or parent change are interesting, because their
1110
 
    # target name may exist in the source tree.  If a directory's name changes,
1111
 
    # that doesn't make its children interesting.
1112
 
    (source_entries, target_entries) = get_rename_entries(changeset, inventory,
1113
 
                                                          reverse)
1114
 
 
1115
 
    changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1116
 
                                              temp_dir, conflict_handler,
1117
 
                                              reverse)
1118
 
 
1119
 
    rename_to_new_create(changed_inventory, target_entries, inventory,
1120
 
                         changeset, dir, conflict_handler, reverse)
1121
 
    os.rmdir(temp_dir)
1122
 
    return changed_inventory
1123
 
 
1124
 
 
1125
 
def apply_changeset_tree(cset, tree, reverse=False):
1126
 
    r_inventory = {}
1127
 
    for entry in tree.source_inventory().itervalues():
1128
 
        inventory[entry.id] = entry.path
1129
 
    new_inventory = apply_changeset(cset, r_inventory, tree.root,
1130
 
                                    reverse=reverse)
1131
 
    new_entries, remove_entries = \
1132
 
        get_inventory_change(inventory, new_inventory, cset, reverse)
1133
 
    tree.update_source_inventory(new_entries, remove_entries)
1134
 
 
1135
 
 
1136
 
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1137
 
    new_entries = {}
1138
 
    remove_entries = []
1139
 
    for entry in cset.entries.itervalues():
1140
 
        if entry.needs_rename():
1141
 
            new_path = entry.get_new_path(inventory, cset)
1142
 
            if new_path is None:
1143
 
                remove_entries.append(entry.id)
1144
 
            else:
1145
 
                new_entries[new_path] = entry.id
1146
 
    return new_entries, remove_entries
1147
 
 
1148
 
 
1149
 
def print_changeset(cset):
1150
 
    """Print all non-boring changeset entries
1151
 
    
1152
 
    :param cset: The changeset to print
1153
 
    :type cset: `Changeset`
1154
 
    """
1155
 
    for entry in cset.entries.itervalues():
1156
 
        if entry.is_boring():
1157
 
            continue
1158
 
        print entry.id
1159
 
        print entry.summarize_name(cset)
1160
 
 
1161
 
class CompositionFailure(Exception):
1162
 
    def __init__(self, old_entry, new_entry, problem):
1163
 
        msg = "Unable to conpose entries.\n %s" % problem
1164
 
        Exception.__init__(self, msg)
1165
 
 
1166
 
class IDMismatch(CompositionFailure):
1167
 
    def __init__(self, old_entry, new_entry):
1168
 
        problem = "Attempt to compose entries with different ids: %s and %s" %\
1169
 
            (old_entry.id, new_entry.id)
1170
 
        CompositionFailure.__init__(self, old_entry, new_entry, problem)
1171
 
 
1172
 
def compose_changesets(old_cset, new_cset):
1173
 
    """Combine two changesets into one.  This works well for exact patching.
1174
 
    Otherwise, not so well.
1175
 
 
1176
 
    :param old_cset: The first changeset that would be applied
1177
 
    :type old_cset: `Changeset`
1178
 
    :param new_cset: The second changeset that would be applied
1179
 
    :type new_cset: `Changeset`
1180
 
    :return: A changeset that combines the changes in both changesets
1181
 
    :rtype: `Changeset`
1182
 
    """
1183
 
    composed = Changeset()
1184
 
    for old_entry in old_cset.entries.itervalues():
1185
 
        new_entry = new_cset.entries.get(old_entry.id)
1186
 
        if new_entry is None:
1187
 
            composed.add_entry(old_entry)
1188
 
        else:
1189
 
            composed_entry = compose_entries(old_entry, new_entry)
1190
 
            if composed_entry.parent is not None or\
1191
 
                composed_entry.new_parent is not None:
1192
 
                composed.add_entry(composed_entry)
1193
 
    for new_entry in new_cset.entries.itervalues():
1194
 
        if not old_cset.entries.has_key(new_entry.id):
1195
 
            composed.add_entry(new_entry)
1196
 
    return composed
1197
 
 
1198
 
def compose_entries(old_entry, new_entry):
1199
 
    """Combine two entries into one.
1200
 
 
1201
 
    :param old_entry: The first entry that would be applied
1202
 
    :type old_entry: ChangesetEntry
1203
 
    :param old_entry: The second entry that would be applied
1204
 
    :type old_entry: ChangesetEntry
1205
 
    :return: A changeset entry combining both entries
1206
 
    :rtype: `ChangesetEntry`
1207
 
    """
1208
 
    if old_entry.id != new_entry.id:
1209
 
        raise IDMismatch(old_entry, new_entry)
1210
 
    output = ChangesetEntry(old_entry.id, old_entry.parent, old_entry.path)
1211
 
 
1212
 
    if (old_entry.parent != old_entry.new_parent or 
1213
 
        new_entry.parent != new_entry.new_parent):
1214
 
        output.new_parent = new_entry.new_parent
1215
 
 
1216
 
    if (old_entry.path != old_entry.new_path or 
1217
 
        new_entry.path != new_entry.new_path):
1218
 
        output.new_path = new_entry.new_path
1219
 
 
1220
 
    output.contents_change = compose_contents(old_entry, new_entry)
1221
 
    output.metadata_change = compose_metadata(old_entry, new_entry)
1222
 
    return output
1223
 
 
1224
 
def compose_contents(old_entry, new_entry):
1225
 
    """Combine the contents of two changeset entries.  Entries are combined
1226
 
    intelligently where possible, but the fallback behavior returns an 
1227
 
    ApplySequence.
1228
 
 
1229
 
    :param old_entry: The first entry that would be applied
1230
 
    :type old_entry: `ChangesetEntry`
1231
 
    :param new_entry: The second entry that would be applied
1232
 
    :type new_entry: `ChangesetEntry`
1233
 
    :return: A combined contents change
1234
 
    :rtype: anything supporting the apply(reverse=False) method
1235
 
    """
1236
 
    old_contents = old_entry.contents_change
1237
 
    new_contents = new_entry.contents_change
1238
 
    if old_entry.contents_change is None:
1239
 
        return new_entry.contents_change
1240
 
    elif new_entry.contents_change is None:
1241
 
        return old_entry.contents_change
1242
 
    elif isinstance(old_contents, ReplaceContents) and \
1243
 
        isinstance(new_contents, ReplaceContents):
1244
 
        if old_contents.old_contents == new_contents.new_contents:
1245
 
            return None
1246
 
        else:
1247
 
            return ReplaceContents(old_contents.old_contents,
1248
 
                                   new_contents.new_contents)
1249
 
    elif isinstance(old_contents, ApplySequence):
1250
 
        output = ApplySequence(old_contents.changes)
1251
 
        if isinstance(new_contents, ApplySequence):
1252
 
            output.changes.extend(new_contents.changes)
1253
 
        else:
1254
 
            output.changes.append(new_contents)
1255
 
        return output
1256
 
    elif isinstance(new_contents, ApplySequence):
1257
 
        output = ApplySequence((old_contents.changes,))
1258
 
        output.extend(new_contents.changes)
1259
 
        return output
1260
 
    else:
1261
 
        return ApplySequence((old_contents, new_contents))
1262
 
 
1263
 
def compose_metadata(old_entry, new_entry):
1264
 
    old_meta = old_entry.metadata_change
1265
 
    new_meta = new_entry.metadata_change
1266
 
    if old_meta is None:
1267
 
        return new_meta
1268
 
    elif new_meta is None:
1269
 
        return old_meta
1270
 
    elif isinstance(old_meta, ChangeUnixPermissions) and \
1271
 
        isinstance(new_meta, ChangeUnixPermissions):
1272
 
        return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1273
 
    else:
1274
 
        return ApplySequence(old_meta, new_meta)
1275
 
 
1276
 
 
1277
 
def changeset_is_null(changeset):
1278
 
    for entry in changeset.entries.itervalues():
1279
 
        if not entry.is_boring():
1280
 
            return False
1281
 
    return True
1282
 
 
1283
 
class UnsuppportedFiletype(Exception):
1284
 
    def __init__(self, full_path, stat_result):
1285
 
        msg = "The file \"%s\" is not a supported filetype." % full_path
1286
 
        Exception.__init__(self, msg)
1287
 
        self.full_path = full_path
1288
 
        self.stat_result = stat_result
1289
 
 
1290
 
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1291
 
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1292
 
 
1293
 
class ChangesetGenerator(object):
1294
 
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1295
 
        object.__init__(self)
1296
 
        self.tree_a = tree_a
1297
 
        self.tree_b = tree_b
1298
 
        self._interesting_ids = interesting_ids
1299
 
 
1300
 
    def iter_both_tree_ids(self):
1301
 
        for file_id in self.tree_a:
1302
 
            yield file_id
1303
 
        for file_id in self.tree_b:
1304
 
            if file_id not in self.tree_a:
1305
 
                yield file_id
1306
 
 
1307
 
    def __call__(self):
1308
 
        cset = Changeset()
1309
 
        for file_id in self.iter_both_tree_ids():
1310
 
            cs_entry = self.make_entry(file_id)
1311
 
            if cs_entry is not None and not cs_entry.is_boring():
1312
 
                cset.add_entry(cs_entry)
1313
 
 
1314
 
        for entry in list(cset.entries.itervalues()):
1315
 
            if entry.parent != entry.new_parent:
1316
 
                if not cset.entries.has_key(entry.parent) and\
1317
 
                    entry.parent != NULL_ID and entry.parent is not None:
1318
 
                    parent_entry = self.make_boring_entry(entry.parent)
1319
 
                    cset.add_entry(parent_entry)
1320
 
                if not cset.entries.has_key(entry.new_parent) and\
1321
 
                    entry.new_parent != NULL_ID and \
1322
 
                    entry.new_parent is not None:
1323
 
                    parent_entry = self.make_boring_entry(entry.new_parent)
1324
 
                    cset.add_entry(parent_entry)
1325
 
        return cset
1326
 
 
1327
 
    def iter_inventory(self, tree):
1328
 
        for file_id in tree:
1329
 
            yield self.get_entry(file_id, tree)
1330
 
 
1331
 
    def get_entry(self, file_id, tree):
1332
 
        if not tree.has_or_had_id(file_id):
1333
 
            return None
1334
 
        return tree.tree.inventory[file_id]
1335
 
 
1336
 
    def get_entry_parent(self, entry):
1337
 
        if entry is None:
1338
 
            return None
1339
 
        return entry.parent_id
1340
 
 
1341
 
    def get_path(self, file_id, tree):
1342
 
        if not tree.has_or_had_id(file_id):
1343
 
            return None
1344
 
        path = tree.id2path(file_id)
1345
 
        if path == '':
1346
 
            return './.'
1347
 
        else:
1348
 
            return path
1349
 
 
1350
 
    def make_basic_entry(self, file_id, only_interesting):
1351
 
        entry_a = self.get_entry(file_id, self.tree_a)
1352
 
        entry_b = self.get_entry(file_id, self.tree_b)
1353
 
        if only_interesting and not self.is_interesting(entry_a, entry_b):
1354
 
            return None
1355
 
        parent = self.get_entry_parent(entry_a)
1356
 
        path = self.get_path(file_id, self.tree_a)
1357
 
        cs_entry = ChangesetEntry(file_id, parent, path)
1358
 
        new_parent = self.get_entry_parent(entry_b)
1359
 
 
1360
 
        new_path = self.get_path(file_id, self.tree_b)
1361
 
 
1362
 
        cs_entry.new_path = new_path
1363
 
        cs_entry.new_parent = new_parent
1364
 
        return cs_entry
1365
 
 
1366
 
    def is_interesting(self, entry_a, entry_b):
1367
 
        if self._interesting_ids is None:
1368
 
            return True
1369
 
        if entry_a is not None:
1370
 
            file_id = entry_a.file_id
1371
 
        elif entry_b is not None:
1372
 
            file_id = entry_b.file_id
1373
 
        else:
1374
 
            return False
1375
 
        return file_id in self._interesting_ids
1376
 
 
1377
 
    def make_boring_entry(self, id):
1378
 
        cs_entry = self.make_basic_entry(id, only_interesting=False)
1379
 
        if cs_entry.is_creation_or_deletion():
1380
 
            return self.make_entry(id, only_interesting=False)
1381
 
        else:
1382
 
            return cs_entry
1383
 
        
1384
 
 
1385
 
    def make_entry(self, id, only_interesting=True):
1386
 
        cs_entry = self.make_basic_entry(id, only_interesting)
1387
 
 
1388
 
        if cs_entry is None:
1389
 
            return None
1390
 
        if id in self.tree_a and id in self.tree_b:
1391
 
            a_sha1 = self.tree_a.get_file_sha1(id)
1392
 
            b_sha1 = self.tree_b.get_file_sha1(id)
1393
 
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1394
 
                return cs_entry
1395
 
 
1396
 
        full_path_a = self.tree_a.readonly_path(id)
1397
 
        full_path_b = self.tree_b.readonly_path(id)
1398
 
        stat_a = self.lstat(full_path_a)
1399
 
        stat_b = self.lstat(full_path_b)
1400
 
        
1401
 
        cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1402
 
        cs_entry.contents_change = self.make_contents_change(full_path_a,
1403
 
                                                             stat_a, 
1404
 
                                                             full_path_b, 
1405
 
                                                             stat_b)
1406
 
        return cs_entry
1407
 
 
1408
 
    def make_mode_change(self, stat_a, stat_b):
1409
 
        mode_a = None
1410
 
        if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1411
 
            mode_a = stat_a.st_mode & 0777
1412
 
        mode_b = None
1413
 
        if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1414
 
            mode_b = stat_b.st_mode & 0777
1415
 
        if mode_a == mode_b:
1416
 
            return None
1417
 
        return ChangeUnixPermissions(mode_a, mode_b)
1418
 
 
1419
 
    def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1420
 
        if stat_a is None and stat_b is None:
1421
 
            return None
1422
 
        if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1423
 
            stat.S_ISDIR(stat_b.st_mode):
1424
 
            return None
1425
 
        if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1426
 
            stat.S_ISREG(stat_b.st_mode):
1427
 
            if stat_a.st_ino == stat_b.st_ino and \
1428
 
                stat_a.st_dev == stat_b.st_dev:
1429
 
                return None
1430
 
 
1431
 
        a_contents = self.get_contents(stat_a, full_path_a)
1432
 
        b_contents = self.get_contents(stat_b, full_path_b)
1433
 
        if a_contents == b_contents:
1434
 
            return None
1435
 
        return ReplaceContents(a_contents, b_contents)
1436
 
 
1437
 
    def get_contents(self, stat_result, full_path):
1438
 
        if stat_result is None:
1439
 
            return None
1440
 
        elif stat.S_ISREG(stat_result.st_mode):
1441
 
            return FileCreate(file(full_path, "rb").read())
1442
 
        elif stat.S_ISDIR(stat_result.st_mode):
1443
 
            return dir_create
1444
 
        elif stat.S_ISLNK(stat_result.st_mode):
1445
 
            return SymlinkCreate(os.readlink(full_path))
1446
 
        else:
1447
 
            raise UnsupportedFiletype(full_path, stat_result)
1448
 
 
1449
 
    def lstat(self, full_path):
1450
 
        stat_result = None
1451
 
        if full_path is not None:
1452
 
            try:
1453
 
                stat_result = os.lstat(full_path)
1454
 
            except OSError, e:
1455
 
                if e.errno != errno.ENOENT:
1456
 
                    raise
1457
 
        return stat_result
1458
 
 
1459
 
 
1460
 
def full_path(entry, tree):
1461
 
    return os.path.join(tree.root, entry.path)
1462
 
 
1463
 
def new_delete_entry(entry, tree, inventory, delete):
1464
 
    if entry.path == "":
1465
 
        parent = NULL_ID
1466
 
    else:
1467
 
        parent = inventory[dirname(entry.path)].id
1468
 
    cs_entry = ChangesetEntry(parent, entry.path)
1469
 
    if delete:
1470
 
        cs_entry.new_path = None
1471
 
        cs_entry.new_parent = None
1472
 
    else:
1473
 
        cs_entry.path = None
1474
 
        cs_entry.parent = None
1475
 
    full_path = full_path(entry, tree)
1476
 
    status = os.lstat(full_path)
1477
 
    if stat.S_ISDIR(file_stat.st_mode):
1478
 
        action = dir_create
1479
 
    
1480
 
 
1481
 
 
1482
 
        
1483
 
# XXX: Can't we unify this with the regular inventory object
1484
 
class Inventory(object):
1485
 
    def __init__(self, inventory):
1486
 
        self.inventory = inventory
1487
 
        self.rinventory = None
1488
 
 
1489
 
    def get_rinventory(self):
1490
 
        if self.rinventory is None:
1491
 
            self.rinventory  = invert_dict(self.inventory)
1492
 
        return self.rinventory
1493
 
 
1494
 
    def get_path(self, id):
1495
 
        return self.inventory.get(id)
1496
 
 
1497
 
    def get_name(self, id):
1498
 
        path = self.get_path(id)
1499
 
        if path is None:
1500
 
            return None
1501
 
        else:
1502
 
            return os.path.basename(path)
1503
 
 
1504
 
    def get_dir(self, id):
1505
 
        path = self.get_path(id)
1506
 
        if path == "":
1507
 
            return None
1508
 
        if path is None:
1509
 
            return None
1510
 
        return os.path.dirname(path)
1511
 
 
1512
 
    def get_parent(self, id):
1513
 
        if self.get_path(id) is None:
1514
 
            return None
1515
 
        directory = self.get_dir(id)
1516
 
        if directory == '.':
1517
 
            directory = './.'
1518
 
        if directory is None:
1519
 
            return NULL_ID
1520
 
        return self.get_rinventory().get(directory)
 
39
        t = bzrlib.transport.get_transport(url)
 
40
        f = t.get(filename)
 
41
        return read_bundle(f)
 
42
    except (errors.TransportError, errors.PathError), e:
 
43
        raise errors.NotABundle(str(e))
 
44
    except (IOError,), e:
 
45
        # jam 20060707
 
46
        # Abstraction leakage, SFTPTransport.get('directory')
 
47
        # doesn't always fail at get() time. Sometimes it fails
 
48
        # during read. And that raises a generic IOError with
 
49
        # just the string 'Failure'
 
50
        # StubSFTPServer does fail during get() (because of prefetch) 
 
51
        # so it has an opportunity to translate the error.
 
52
        raise errors.NotABundle(str(e))
 
53