« back to all changes in this revision
Viewing changes to bzrlib/weave.py
- browse files at revision 1399
- compare with another revision
- download diff
- download tarball
- view history from revision 1399
- Committer: Robert Collins
- Date: 2005-10-03 01:53:47 UTC
- Revision ID: robertc@robertcollins.net-20051003015347-dbabc1b75766f1c5
Patch from Heikki Paajanen testing status on specific files
- files added:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- patches
- tools
- files removed:
- bzrlib/cache.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- contrib/bash/bzr => contrib/bash/bzr.simple
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
added
removed
bzrlib/weave.py
1
#! /usr/bin/python
2
3
# Copyright (C) 2005 Canonical Ltd
4
5
# This program is free software; you can redistribute it and/or modify
6
# it under the terms of the GNU General Public License as published by
7
# the Free Software Foundation; either version 2 of the License, or
8
# (at your option) any later version.
9
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
# GNU General Public License for more details.
14
15
# You should have received a copy of the GNU General Public License
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
19
# Author: Martin Pool <mbp@canonical.com>
20
21
22
"""Weave - storage of related text file versions"""
23
24
# before intset (r923) 2000 versions in 41.5s
25
# with intset (r926) 2000 versions in 93s !!!
26
# better to just use plain sets.
27
28
# making _extract build and return a list, rather than being a generator
29
# takes 37.94s
30
31
# with python -O, r923 does 2000 versions in 36.87s
32
33
# with optimizations to avoid mutating lists - 35.75! I guess copying
34
# all the elements every time costs more than the small manipulations.
35
# a surprisingly small change.
36
37
# r931, which avoids using a generator for extract, does 36.98s
38
39
# with memoized inclusions, takes 41.49s; not very good
40
41
# with slots, takes 37.35s; without takes 39.16, a bit surprising
42
43
# with the delta calculation mixed in with the add method, rather than
44
# separated, takes 36.78s
45
46
# with delta folded in and mutation of the list, 36.13s
47
48
# with all this and simplification of add code, 33s
49
50
51
52
53
54
# TODO: Perhaps have copy method for Weave instances?
55
56
# XXX: If we do weaves this way, will a merge still behave the same
57
# way if it's done in a different order? That's a pretty desirable
58
# property.
59
60
# TODO: Nothing here so far assumes the lines are really \n newlines,
61
# rather than being split up in some other way. We could accomodate
62
# binaries, perhaps by naively splitting on \n or perhaps using
63
# something like a rolling checksum.
64
65
# TODO: End marker for each version so we can stop reading?
66
67
# TODO: Check that no insertion occurs inside a deletion that was
68
# active in the version of the insertion.
69
70
# TODO: In addition to the SHA-1 check, perhaps have some code that
71
# checks structural constraints of the weave: ie that insertions are
72
# properly nested, that there is no text outside of an insertion, that
73
# insertions or deletions are not repeated, etc.
74
75
# TODO: Parallel-extract that passes back each line along with a
76
# description of which revisions include it. Nice for checking all
77
# shas in parallel.
78
79
# TODO: Using a single _extract routine and then processing the output
80
# is probably inefficient. It's simple enough that we can afford to
81
# have slight specializations for different ways its used: annotate,
82
# basis for add, get, etc.
83
84
# TODO: Perhaps the API should work only in names to hide the integer
85
# indexes from the user?
86
87
# TODO: Is there any potential performance win by having an add()
88
# variant that is passed a pre-cooked version of the single basis
89
# version?
90
91
92
93
import sha
94
from difflib import SequenceMatcher
95
96
97
98
99
class WeaveError(Exception):
100
"""Exception in processing weave"""
101
102
103
class WeaveFormatError(WeaveError):
104
"""Weave invariant violated"""
105
106
107
class Weave(object):
108
"""weave - versioned text file storage.
109
110
A Weave manages versions of line-based text files, keeping track
111
of the originating version for each line.
112
113
To clients the "lines" of the file are represented as a list of strings.
114
These strings will typically have terminal newline characters, but
115
this is not required. In particular files commonly do not have a newline
116
at the end of the file.
117
118
Texts can be identified in either of two ways:
119
120
* a nonnegative index number.
121
122
* a version-id string.
123
124
Typically the index number will be valid only inside this weave and
125
the version-id is used to reference it in the larger world.
126
127
The weave is represented as a list mixing edit instructions and
128
literal text. Each entry in _weave can be either a string (or
129
unicode), or a tuple. If a string, it means that the given line
130
should be output in the currently active revisions.
131
132
If a tuple, it gives a processing instruction saying in which
133
revisions the enclosed lines are active. The tuple has the form
134
(instruction, version).
135
136
The instruction can be '{' or '}' for an insertion block, and '['
137
and ']' for a deletion block respectively. The version is the
138
integer version index. There is no replace operator, only deletes
139
and inserts. For '}', the end of an insertion, there is no
140
version parameter because it always closes the most recently
141
opened insertion.
142
143
Constraints/notes:
144
145
* A later version can delete lines that were introduced by any
146
number of ancestor versions; this implies that deletion
147
instructions can span insertion blocks without regard to the
148
insertion block's nesting.
149
150
* Similarly, deletions need not be properly nested with regard to
151
each other, because they might have been generated by
152
independent revisions.
153
154
* Insertions are always made by inserting a new bracketed block
155
into a single point in the previous weave. This implies they
156
can nest but not overlap, and the nesting must always have later
157
insertions on the inside.
158
159
* It doesn't seem very useful to have an active insertion
160
inside an inactive insertion, but it might happen.
161
162
* Therefore, all instructions are always"considered"; that
163
is passed onto and off the stack. An outer inactive block
164
doesn't disable an inner block.
165
166
* Lines are enabled if the most recent enclosing insertion is
167
active and none of the enclosing deletions are active.
168
169
* There is no point having a deletion directly inside its own
170
insertion; you might as well just not write it. And there
171
should be no way to get an earlier version deleting a later
172
version.
173
174
_weave
175
Text of the weave; list of control instruction tuples and strings.
176
177
_parents
178
List of parents, indexed by version number.
179
It is only necessary to store the minimal set of parents for
180
each version; the parent's parents are implied.
181
182
_sha1s
183
List of hex SHA-1 of each version.
184
185
_names
186
List of symbolic names for each version. Each should be unique.
187
188
_name_map
189
For each name, the version number.
190
191
_weave_name
192
Descriptive name of this weave; typically the filename if known.
193
Set by read_weave.
194
"""
195
196
__slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
197
'_weave_name']
198
199
def __init__(self, weave_name=None):
200
self._weave = []
201
self._parents = []
202
self._sha1s = []
203
self._names = []
204
self._name_map = {}
205
self._weave_name = weave_name
206
207
208
def __eq__(self, other):
209
if not isinstance(other, Weave):
210
return False
211
return self._parents == other._parents \
212
and self._weave == other._weave \
213
and self._sha1s == other._sha1s
214
215
216
def __ne__(self, other):
217
return not self.__eq__(other)
218
219
220
def maybe_lookup(self, name_or_index):
221
"""Convert possible symbolic name to index, or pass through indexes."""
222
if isinstance(name_or_index, (int, long)):
223
return name_or_index
224
else:
225
return self.lookup(name_or_index)
226
227
228
def lookup(self, name):
229
"""Convert symbolic version name to index."""
230
try:
231
return self._name_map[name]
232
except KeyError:
233
raise WeaveError("name %r not present in weave %r" %
234
(name, self._weave_name))
235
236
237
def idx_to_name(self, version):
238
return self._names[version]
239
240
241
def _check_repeated_add(self, name, parents, text, sha1):
242
"""Check that a duplicated add is OK.
243
244
If it is, return the (old) index; otherwise raise an exception.
245
"""
246
idx = self.lookup(name)
247
if sorted(self._parents[idx]) != sorted(parents):
248
raise WeaveError("name \"%s\" already present in weave "
249
"with different parents" % name)
250
if sha1 != self._sha1s[idx]:
251
raise WeaveError("name \"%s\" already present in weave "
252
"with different text" % name)
253
return idx
254
255
256
257
def add(self, name, parents, text, sha1=None):
258
"""Add a single text on top of the weave.
259
260
Returns the index number of the newly added version.
261
262
name
263
Symbolic name for this version.
264
(Typically the revision-id of the revision that added it.)
265
266
parents
267
List or set of direct parent version numbers.
268
269
text
270
Sequence of lines to be added in the new version.
271
272
sha -- SHA-1 of the file, if known. This is trusted to be
273
correct if supplied.
274
"""
275
from bzrlib.osutils import sha_strings
276
277
assert isinstance(name, basestring)
278
if sha1 is None:
279
sha1 = sha_strings(text)
280
if name in self._name_map:
281
return self._check_repeated_add(name, parents, text, sha1)
282
283
parents = map(self.maybe_lookup, parents)
284
self._check_versions(parents)
285
## self._check_lines(text)
286
new_version = len(self._parents)
287
288
289
# if we abort after here the (in-memory) weave will be corrupt because only
290
# some fields are updated
291
self._parents.append(parents[:])
292
self._sha1s.append(sha1)
293
self._names.append(name)
294
self._name_map[name] = new_version
295
296
297
if not parents:
298
# special case; adding with no parents revision; can do
299
# this more quickly by just appending unconditionally.
300
# even more specially, if we're adding an empty text we
301
# need do nothing at all.
302
if text:
303
self._weave.append(('{', new_version))
304
self._weave.extend(text)
305
self._weave.append(('}', None))
306
307
return new_version
308
309
if len(parents) == 1:
310
pv = list(parents)[0]
311
if sha1 == self._sha1s[pv]:
312
# special case: same as the single parent
313
return new_version
314
315
316
ancestors = self.inclusions(parents)
317
318
l = self._weave
319
320
# basis a list of (origin, lineno, line)
321
basis_lineno = []
322
basis_lines = []
323
for origin, lineno, line in self._extract(ancestors):
324
basis_lineno.append(lineno)
325
basis_lines.append(line)
326
327
# another small special case: a merge, producing the same text
328
# as auto-merge
329
if text == basis_lines:
330
return new_version
331
332
# add a sentinal, because we can also match against the final line
333
basis_lineno.append(len(self._weave))
334
335
# XXX: which line of the weave should we really consider
336
# matches the end of the file? the current code says it's the
337
# last line of the weave?
338
339
#print 'basis_lines:', basis_lines
340
#print 'new_lines: ', lines
341
342
s = SequenceMatcher(None, basis_lines, text)
343
344
# offset gives the number of lines that have been inserted
345
# into the weave up to the current point; if the original edit instruction
346
# says to change line A then we actually change (A+offset)
347
offset = 0
348
349
for tag, i1, i2, j1, j2 in s.get_opcodes():
350
# i1,i2 are given in offsets within basis_lines; we need to map them
351
# back to offsets within the entire weave
352
#print 'raw match', tag, i1, i2, j1, j2
353
if tag == 'equal':
354
continue
355
356
i1 = basis_lineno[i1]
357
i2 = basis_lineno[i2]
358
359
assert 0 <= j1 <= j2 <= len(text)
360
361
#print tag, i1, i2, j1, j2
362
363
# the deletion and insertion are handled separately.
364
# first delete the region.
365
if i1 != i2:
366
self._weave.insert(i1+offset, ('[', new_version))
367
self._weave.insert(i2+offset+1, (']', new_version))
368
offset += 2
369
370
if j1 != j2:
371
# there may have been a deletion spanning up to
372
# i2; we want to insert after this region to make sure
373
# we don't destroy ourselves
374
i = i2 + offset
375
self._weave[i:i] = ([('{', new_version)]
376
+ text[j1:j2]
377
+ [('}', None)])
378
offset += 2 + (j2 - j1)
379
380
return new_version
381
382
def add_identical(self, old_rev_id, new_rev_id, parents):
383
"""Add an identical text to old_rev_id as new_rev_id."""
384
old_lines = self.get(self.lookup(old_rev_id))
385
self.add(new_rev_id, parents, old_lines)
386
387
def inclusions(self, versions):
388
"""Return set of all ancestors of given version(s)."""
389
i = set(versions)
390
for v in xrange(max(versions), 0, -1):
391
if v in i:
392
# include all its parents
393
i.update(self._parents[v])
394
return i
395
## except IndexError:
396
## raise ValueError("version %d not present in weave" % v)
397
398
399
def parents(self, version):
400
return self._parents[version]
401
402
403
def minimal_parents(self, version):
404
"""Find the minimal set of parents for the version."""
405
included = self._parents[version]
406
if not included:
407
return []
408
409
li = list(included)
410
li.sort(reverse=True)
411
412
mininc = []
413
gotit = set()
414
415
for pv in li:
416
if pv not in gotit:
417
mininc.append(pv)
418
gotit.update(self.inclusions(pv))
419
420
assert mininc[0] >= 0
421
assert mininc[-1] < version
422
return mininc
423
424
425
426
def _check_lines(self, text):
427
if not isinstance(text, list):
428
raise ValueError("text should be a list, not %s" % type(text))
429
430
for l in text:
431
if not isinstance(l, basestring):
432
raise ValueError("text line should be a string or unicode, not %s"
433
% type(l))
434
435
436
437
def _check_versions(self, indexes):
438
"""Check everything in the sequence of indexes is valid"""
439
for i in indexes:
440
try:
441
self._parents[i]
442
except IndexError:
443
raise IndexError("invalid version number %r" % i)
444
445
446
def annotate(self, name_or_index):
447
return list(self.annotate_iter(name_or_index))
448
449
450
def annotate_iter(self, name_or_index):
451
"""Yield list of (index-id, line) pairs for the specified version.
452
453
The index indicates when the line originated in the weave."""
454
incls = [self.maybe_lookup(name_or_index)]
455
for origin, lineno, text in self._extract(incls):
456
yield origin, text
457
458
459
def _walk(self):
460
"""Walk the weave.
461
462
Yields sequence of
463
(lineno, insert, deletes, text)
464
for each literal line.
465
"""
466
467
istack = []
468
dset = set()
469
470
lineno = 0 # line of weave, 0-based
471
472
for l in self._weave:
473
if isinstance(l, tuple):
474
c, v = l
475
isactive = None
476
if c == '{':
477
istack.append(v)
478
elif c == '}':
479
istack.pop()
480
elif c == '[':
481
assert v not in dset
482
dset.add(v)
483
elif c == ']':
484
dset.remove(v)
485
else:
486
raise WeaveFormatError('unexpected instruction %r'
487
% v)
488
else:
489
assert isinstance(l, basestring)
490
assert istack
491
yield lineno, istack[-1], dset, l
492
lineno += 1
493
494
495
496
def _extract(self, versions):
497
"""Yield annotation of lines in included set.
498
499
Yields a sequence of tuples (origin, lineno, text), where
500
origin is the origin version, lineno the index in the weave,
501
and text the text of the line.
502
503
The set typically but not necessarily corresponds to a version.
504
"""
505
for i in versions:
506
if not isinstance(i, int):
507
raise ValueError(i)
508
509
included = self.inclusions(versions)
510
511
istack = []
512
dset = set()
513
514
lineno = 0 # line of weave, 0-based
515
516
isactive = None
517
518
result = []
519
520
WFE = WeaveFormatError
521
522
for l in self._weave:
523
if isinstance(l, tuple):
524
c, v = l
525
isactive = None
526
if c == '{':
527
assert v not in istack
528
istack.append(v)
529
elif c == '}':
530
istack.pop()
531
elif c == '[':
532
if v in included:
533
assert v not in dset
534
dset.add(v)
535
else:
536
assert c == ']'
537
if v in included:
538
assert v in dset
539
dset.remove(v)
540
else:
541
assert isinstance(l, basestring)
542
if isactive is None:
543
isactive = (not dset) and istack and (istack[-1] in included)
544
if isactive:
545
result.append((istack[-1], lineno, l))
546
lineno += 1
547
548
if istack:
549
raise WFE("unclosed insertion blocks at end of weave",
550
istack)
551
if dset:
552
raise WFE("unclosed deletion blocks at end of weave",
553
dset)
554
555
return result
556
557
558
559
def get_iter(self, name_or_index):
560
"""Yield lines for the specified version."""
561
incls = [self.maybe_lookup(name_or_index)]
562
for origin, lineno, line in self._extract(incls):
563
yield line
564
565
566
def get_text(self, name_or_index):
567
return ''.join(self.get_iter(name_or_index))
568
assert isinstance(version, int)
569
570
571
def get_lines(self, name_or_index):
572
return list(self.get_iter(name_or_index))
573
574
575
get = get_lines
576
577
578
def mash_iter(self, included):
579
"""Return composed version of multiple included versions."""
580
included = map(self.maybe_lookup, included)
581
for origin, lineno, text in self._extract(included):
582
yield text
583
584
585
def dump(self, to_file):
586
from pprint import pprint
587
print >>to_file, "Weave._weave = ",
588
pprint(self._weave, to_file)
589
print >>to_file, "Weave._parents = ",
590
pprint(self._parents, to_file)
591
592
593
594
def numversions(self):
595
l = len(self._parents)
596
assert l == len(self._sha1s)
597
return l
598
599
600
def __len__(self):
601
return self.numversions()
602
603
604
def check(self, progress_bar=None):
605
# check no circular inclusions
606
for version in range(self.numversions()):
607
inclusions = list(self._parents[version])
608
if inclusions:
609
inclusions.sort()
610
if inclusions[-1] >= version:
611
raise WeaveFormatError("invalid included version %d for index %d"
612
% (inclusions[-1], version))
613
614
# try extracting all versions; this is a bit slow and parallel
615
# extraction could be used
616
nv = self.numversions()
617
for version in range(nv):
618
if progress_bar:
619
progress_bar.update('checking text', version, nv)
620
s = sha.new()
621
for l in self.get_iter(version):
622
s.update(l)
623
hd = s.hexdigest()
624
expected = self._sha1s[version]
625
if hd != expected:
626
raise WeaveError("mismatched sha1 for version %d; "
627
"got %s, expected %s"
628
% (version, hd, expected))
629
630
# TODO: check insertions are properly nested, that there are
631
# no lines outside of insertion blocks, that deletions are
632
# properly paired, etc.
633
634
635
636
def merge(self, merge_versions):
637
"""Automerge and mark conflicts between versions.
638
639
This returns a sequence, each entry describing alternatives
640
for a chunk of the file. Each of the alternatives is given as
641
a list of lines.
642
643
If there is a chunk of the file where there's no diagreement,
644
only one alternative is given.
645
"""
646
647
# approach: find the included versions common to all the
648
# merged versions
649
raise NotImplementedError()
650
651
652
653
def _delta(self, included, lines):
654
"""Return changes from basis to new revision.
655
656
The old text for comparison is the union of included revisions.
657
658
This is used in inserting a new text.
659
660
Delta is returned as a sequence of
661
(weave1, weave2, newlines).
662
663
This indicates that weave1:weave2 of the old weave should be
664
replaced by the sequence of lines in newlines. Note that
665
these line numbers are positions in the total weave and don't
666
correspond to the lines in any extracted version, or even the
667
extracted union of included versions.
668
669
If line1=line2, this is a pure insert; if newlines=[] this is a
670
pure delete. (Similar to difflib.)
671
"""
672
673
674
675
def plan_merge(self, ver_a, ver_b):
676
"""Return pseudo-annotation indicating how the two versions merge.
677
678
This is computed between versions a and b and their common
679
base.
680
681
Weave lines present in none of them are skipped entirely.
682
"""
683
inc_a = self.inclusions([ver_a])
684
inc_b = self.inclusions([ver_b])
685
inc_c = inc_a & inc_b
686
687
for lineno, insert, deleteset, line in self._walk():
688
if deleteset & inc_c:
689
# killed in parent; can't be in either a or b
690
# not relevant to our work
691
yield 'killed-base', line
692
elif insert in inc_c:
693
# was inserted in base
694
killed_a = bool(deleteset & inc_a)
695
killed_b = bool(deleteset & inc_b)
696
if killed_a and killed_b:
697
yield 'killed-both', line
698
elif killed_a:
699
yield 'killed-a', line
700
elif killed_b:
701
yield 'killed-b', line
702
else:
703
yield 'unchanged', line
704
elif insert in inc_a:
705
if deleteset & inc_a:
706
yield 'ghost-a', line
707
else:
708
# new in A; not in B
709
yield 'new-a', line
710
elif insert in inc_b:
711
if deleteset & inc_b:
712
yield 'ghost-b', line
713
else:
714
yield 'new-b', line
715
else:
716
# not in either revision
717
yield 'irrelevant', line
718
719
yield 'unchanged', '' # terminator
720
721
722
723
def weave_merge(self, plan):
724
lines_a = []
725
lines_b = []
726
ch_a = ch_b = False
727
728
for state, line in plan:
729
if state == 'unchanged' or state == 'killed-both':
730
# resync and flush queued conflicts changes if any
731
if not lines_a and not lines_b:
732
pass
733
elif ch_a and not ch_b:
734
# one-sided change:
735
for l in lines_a: yield l
736
elif ch_b and not ch_a:
737
for l in lines_b: yield l
738
elif lines_a == lines_b:
739
for l in lines_a: yield l
740
else:
741
yield '<<<<\n'
742
for l in lines_a: yield l
743
yield '====\n'
744
for l in lines_b: yield l
745
yield '>>>>\n'
746
747
del lines_a[:]
748
del lines_b[:]
749
ch_a = ch_b = False
750
751
if state == 'unchanged':
752
if line:
753
yield line
754
elif state == 'killed-a':
755
ch_a = True
756
lines_b.append(line)
757
elif state == 'killed-b':
758
ch_b = True
759
lines_a.append(line)
760
elif state == 'new-a':
761
ch_a = True
762
lines_a.append(line)
763
elif state == 'new-b':
764
ch_b = True
765
lines_b.append(line)
766
else:
767
assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
768
'killed-both'), \
769
state
770
771
772
773
774
775
776
777
def weave_toc(w):
778
"""Show the weave's table-of-contents"""
779
print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
780
for i in (6, 50, 10, 10):
781
print '-' * i,
782
print
783
for i in range(w.numversions()):
784
sha1 = w._sha1s[i]
785
name = w._names[i]
786
parent_str = ' '.join(map(str, w._parents[i]))
787
print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
788
789
790
791
def weave_stats(weave_file, pb):
792
from bzrlib.weavefile import read_weave
793
794
wf = file(weave_file, 'rb')
795
w = read_weave(wf)
796
# FIXME: doesn't work on pipes
797
weave_size = wf.tell()
798
799
total = 0
800
vers = len(w)
801
for i in range(vers):
802
pb.update('checking sizes', i, vers)
803
for line in w.get_iter(i):
804
total += len(line)
805
806
pb.clear()
807
808
print 'versions %9d' % vers
809
print 'weave file %9d bytes' % weave_size
810
print 'total contents %9d bytes' % total
811
print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
812
if vers:
813
avg = total/vers
814
print 'average size %9d bytes' % avg
815
print 'relative size %9.2fx' % (float(weave_size) / float(avg))
816
817
818
def usage():
819
print """bzr weave tool
820
821
Experimental tool for weave algorithm.
822
823
usage:
824
weave init WEAVEFILE
825
Create an empty weave file
826
weave get WEAVEFILE VERSION
827
Write out specified version.
828
weave check WEAVEFILE
829
Check consistency of all versions.
830
weave toc WEAVEFILE
831
Display table of contents.
832
weave add WEAVEFILE NAME [BASE...] < NEWTEXT
833
Add NEWTEXT, with specified parent versions.
834
weave annotate WEAVEFILE VERSION
835
Display origin of each line.
836
weave mash WEAVEFILE VERSION...
837
Display composite of all selected versions.
838
weave merge WEAVEFILE VERSION1 VERSION2 > OUT
839
Auto-merge two versions and display conflicts.
840
weave diff WEAVEFILE VERSION1 VERSION2
841
Show differences between two versions.
842
843
example:
844
845
% weave init foo.weave
846
% vi foo.txt
847
% weave add foo.weave ver0 < foo.txt
848
added version 0
849
850
(create updated version)
851
% vi foo.txt
852
% weave get foo.weave 0 | diff -u - foo.txt
853
% weave add foo.weave ver1 0 < foo.txt
854
added version 1
855
856
% weave get foo.weave 0 > foo.txt (create forked version)
857
% vi foo.txt
858
% weave add foo.weave ver2 0 < foo.txt
859
added version 2
860
861
% weave merge foo.weave 1 2 > foo.txt (merge them)
862
% vi foo.txt (resolve conflicts)
863
% weave add foo.weave merged 1 2 < foo.txt (commit merged version)
864
865
"""
866
867
868
869
def main(argv):
870
import sys
871
import os
872
try:
873
import bzrlib
874
except ImportError:
875
# in case we're run directly from the subdirectory
876
sys.path.append('..')
877
import bzrlib
878
from bzrlib.weavefile import write_weave, read_weave
879
from bzrlib.progress import ProgressBar
880
881
try:
882
import psyco
883
psyco.full()
884
except ImportError:
885
pass
886
887
if len(argv) < 2:
888
usage()
889
return 0
890
891
cmd = argv[1]
892
893
def readit():
894
return read_weave(file(argv[2], 'rb'))
895
896
if cmd == 'help':
897
usage()
898
elif cmd == 'add':
899
w = readit()
900
# at the moment, based on everything in the file
901
name = argv[3]
902
parents = map(int, argv[4:])
903
lines = sys.stdin.readlines()
904
ver = w.add(name, parents, lines)
905
write_weave(w, file(argv[2], 'wb'))
906
print 'added version %r %d' % (name, ver)
907
elif cmd == 'init':
908
fn = argv[2]
909
if os.path.exists(fn):
910
raise IOError("file exists")
911
w = Weave()
912
write_weave(w, file(fn, 'wb'))
913
elif cmd == 'get': # get one version
914
w = readit()
915
sys.stdout.writelines(w.get_iter(int(argv[3])))
916
917
elif cmd == 'mash': # get composite
918
w = readit()
919
sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
920
921
elif cmd == 'diff':
922
from difflib import unified_diff
923
w = readit()
924
fn = argv[2]
925
v1, v2 = map(int, argv[3:5])
926
lines1 = w.get(v1)
927
lines2 = w.get(v2)
928
diff_gen = unified_diff(lines1, lines2,
929
'%s version %d' % (fn, v1),
930
'%s version %d' % (fn, v2))
931
sys.stdout.writelines(diff_gen)
932
933
elif cmd == 'annotate':
934
w = readit()
935
# newline is added to all lines regardless; too hard to get
936
# reasonable formatting otherwise
937
lasto = None
938
for origin, text in w.annotate(int(argv[3])):
939
text = text.rstrip('\r\n')
940
if origin == lasto:
941
print ' | %s' % (text)
942
else:
943
print '%5d | %s' % (origin, text)
944
lasto = origin
945
946
elif cmd == 'toc':
947
weave_toc(readit())
948
949
elif cmd == 'stats':
950
weave_stats(argv[2], ProgressBar())
951
952
elif cmd == 'check':
953
w = readit()
954
pb = ProgressBar()
955
w.check(pb)
956
pb.clear()
957
print '%d versions ok' % w.numversions()
958
959
elif cmd == 'inclusions':
960
w = readit()
961
print ' '.join(map(str, w.inclusions([int(argv[3])])))
962
963
elif cmd == 'parents':
964
w = readit()
965
print ' '.join(map(str, w._parents[int(argv[3])]))
966
967
elif cmd == 'plan-merge':
968
w = readit()
969
for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
970
if line:
971
print '%14s | %s' % (state, line),
972
973
elif cmd == 'merge':
974
w = readit()
975
p = w.plan_merge(int(argv[3]), int(argv[4]))
976
sys.stdout.writelines(w.weave_merge(p))
977
978
elif cmd == 'mash-merge':
979
if len(argv) != 5:
980
usage()
981
return 1
982
983
w = readit()
984
v1, v2 = map(int, argv[3:5])
985
986
basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
987
988
base_lines = list(w.mash_iter(basis))
989
a_lines = list(w.get(v1))
990
b_lines = list(w.get(v2))
991
992
from bzrlib.merge3 import Merge3
993
m3 = Merge3(base_lines, a_lines, b_lines)
994
995
name_a = 'version %d' % v1
996
name_b = 'version %d' % v2
997
sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
998
else:
999
raise ValueError('unknown command %r' % cmd)
1000
1001
1002
1003
def profile_main(argv):
1004
import tempfile, hotshot, hotshot.stats
1005
1006
prof_f = tempfile.NamedTemporaryFile()
1007
1008
prof = hotshot.Profile(prof_f.name)
1009
1010
ret = prof.runcall(main, argv)
1011
prof.close()
1012
1013
stats = hotshot.stats.load(prof_f.name)
1014
#stats.strip_dirs()
1015
stats.sort_stats('cumulative')
1016
## XXX: Might like to write to stderr or the trace file instead but
1017
## print_stats seems hardcoded to stdout
1018
stats.print_stats(20)
1019
1020
return ret
1021
1022
1023
if __name__ == '__main__':
1024
import sys
1025
if '--profile' in sys.argv:
1026
args = sys.argv[:]
1027
args.remove('--profile')
1028
sys.exit(profile_main(args))
1029
else:
1030
sys.exit(main(sys.argv))
1031
Loggerhead is a web-based interface for Breezy
Version: 2.0.1