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