« back to all changes in this revision
Viewing changes to bzrlib/weave.py
- browse files at revision 1393.1.2
- compare with another revision
- download diff
- download tarball
- view history from revision 1393.1.2
- Committer: Martin Pool
- Date: 2005-09-29 03:44:15 UTC
- mto: (1185.12.2) (1393.1.12)
- mto: This revision was merged to the branch mainline in revision 1396.
- Revision ID: mbp@sourcefrog.net-20050929034415-653b0359e30f62e7
- better representation in Branch factories of opening old formats
- files added:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- elementtree/ => bzrlib/util/elementtree/
- 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
from bzrlib.osutils import sha_strings
98
99
100
class WeaveError(Exception):
101
"""Exception in processing weave"""
102
103
104
class WeaveFormatError(WeaveError):
105
"""Weave invariant violated"""
106
107
108
class Weave(object):
109
"""weave - versioned text file storage.
110
111
A Weave manages versions of line-based text files, keeping track
112
of the originating version for each line.
113
114
To clients the "lines" of the file are represented as a list of strings.
115
These strings will typically have terminal newline characters, but
116
this is not required. In particular files commonly do not have a newline
117
at the end of the file.
118
119
Texts can be identified in either of two ways:
120
121
* a nonnegative index number.
122
123
* a version-id string.
124
125
Typically the index number will be valid only inside this weave and
126
the version-id is used to reference it in the larger world.
127
128
The weave is represented as a list mixing edit instructions and
129
literal text. Each entry in _weave can be either a string (or
130
unicode), or a tuple. If a string, it means that the given line
131
should be output in the currently active revisions.
132
133
If a tuple, it gives a processing instruction saying in which
134
revisions the enclosed lines are active. The tuple has the form
135
(instruction, version).
136
137
The instruction can be '{' or '}' for an insertion block, and '['
138
and ']' for a deletion block respectively. The version is the
139
integer version index. There is no replace operator, only deletes
140
and inserts. For '}', the end of an insertion, there is no
141
version parameter because it always closes the most recently
142
opened insertion.
143
144
Constraints/notes:
145
146
* A later version can delete lines that were introduced by any
147
number of ancestor versions; this implies that deletion
148
instructions can span insertion blocks without regard to the
149
insertion block's nesting.
150
151
* Similarly, deletions need not be properly nested with regard to
152
each other, because they might have been generated by
153
independent revisions.
154
155
* Insertions are always made by inserting a new bracketed block
156
into a single point in the previous weave. This implies they
157
can nest but not overlap, and the nesting must always have later
158
insertions on the inside.
159
160
* It doesn't seem very useful to have an active insertion
161
inside an inactive insertion, but it might happen.
162
163
* Therefore, all instructions are always"considered"; that
164
is passed onto and off the stack. An outer inactive block
165
doesn't disable an inner block.
166
167
* Lines are enabled if the most recent enclosing insertion is
168
active and none of the enclosing deletions are active.
169
170
* There is no point having a deletion directly inside its own
171
insertion; you might as well just not write it. And there
172
should be no way to get an earlier version deleting a later
173
version.
174
175
_weave
176
Text of the weave; list of control instruction tuples and strings.
177
178
_parents
179
List of parents, indexed by version number.
180
It is only necessary to store the minimal set of parents for
181
each version; the parent's parents are implied.
182
183
_sha1s
184
List of hex SHA-1 of each version.
185
186
_names
187
List of symbolic names for each version. Each should be unique.
188
189
_name_map
190
For each name, the version number.
191
192
_weave_name
193
Descriptive name of this weave; typically the filename if known.
194
Set by read_weave.
195
"""
196
197
__slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
198
'_weave_name']
199
200
def __init__(self, weave_name=None):
201
self._weave = []
202
self._parents = []
203
self._sha1s = []
204
self._names = []
205
self._name_map = {}
206
self._weave_name = weave_name
207
208
209
def __eq__(self, other):
210
if not isinstance(other, Weave):
211
return False
212
return self._parents == other._parents \
213
and self._weave == other._weave \
214
and self._sha1s == other._sha1s
215
216
217
def __ne__(self, other):
218
return not self.__eq__(other)
219
220
221
def maybe_lookup(self, name_or_index):
222
"""Convert possible symbolic name to index, or pass through indexes."""
223
if isinstance(name_or_index, (int, long)):
224
return name_or_index
225
else:
226
return self.lookup(name_or_index)
227
228
229
def lookup(self, name):
230
"""Convert symbolic version name to index."""
231
try:
232
return self._name_map[name]
233
except KeyError:
234
raise WeaveError("name %r not present in weave %r" %
235
(name, self._weave_name))
236
237
238
def idx_to_name(self, version):
239
return self._names[version]
240
241
242
def _check_repeated_add(self, name, parents, text, sha1):
243
"""Check that a duplicated add is OK.
244
245
If it is, return the (old) index; otherwise raise an exception.
246
"""
247
idx = self.lookup(name)
248
if sorted(self._parents[idx]) != sorted(parents):
249
raise WeaveError("name \"%s\" already present in weave "
250
"with different parents" % name)
251
if sha1 != self._sha1s[idx]:
252
raise WeaveError("name \"%s\" already present in weave "
253
"with different text" % name)
254
return idx
255
256
257
258
def add(self, name, parents, text, sha1=None):
259
"""Add a single text on top of the weave.
260
261
Returns the index number of the newly added version.
262
263
name
264
Symbolic name for this version.
265
(Typically the revision-id of the revision that added it.)
266
267
parents
268
List or set of direct parent version numbers.
269
270
text
271
Sequence of lines to be added in the new version.
272
273
sha -- SHA-1 of the file, if known. This is trusted to be
274
correct if supplied.
275
"""
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
383
def inclusions(self, versions):
384
"""Return set of all ancestors of given version(s)."""
385
i = set(versions)
386
for v in xrange(max(versions), 0, -1):
387
if v in i:
388
# include all its parents
389
i.update(self._parents[v])
390
return i
391
## except IndexError:
392
## raise ValueError("version %d not present in weave" % v)
393
394
395
def parents(self, version):
396
return self._parents[version]
397
398
399
def minimal_parents(self, version):
400
"""Find the minimal set of parents for the version."""
401
included = self._parents[version]
402
if not included:
403
return []
404
405
li = list(included)
406
li.sort(reverse=True)
407
408
mininc = []
409
gotit = set()
410
411
for pv in li:
412
if pv not in gotit:
413
mininc.append(pv)
414
gotit.update(self.inclusions(pv))
415
416
assert mininc[0] >= 0
417
assert mininc[-1] < version
418
return mininc
419
420
421
422
def _check_lines(self, text):
423
if not isinstance(text, list):
424
raise ValueError("text should be a list, not %s" % type(text))
425
426
for l in text:
427
if not isinstance(l, basestring):
428
raise ValueError("text line should be a string or unicode, not %s"
429
% type(l))
430
431
432
433
def _check_versions(self, indexes):
434
"""Check everything in the sequence of indexes is valid"""
435
for i in indexes:
436
try:
437
self._parents[i]
438
except IndexError:
439
raise IndexError("invalid version number %r" % i)
440
441
442
def annotate(self, name_or_index):
443
return list(self.annotate_iter(name_or_index))
444
445
446
def annotate_iter(self, name_or_index):
447
"""Yield list of (index-id, line) pairs for the specified version.
448
449
The index indicates when the line originated in the weave."""
450
incls = [self.maybe_lookup(name_or_index)]
451
for origin, lineno, text in self._extract(incls):
452
yield origin, text
453
454
455
def _walk(self):
456
"""Walk the weave.
457
458
Yields sequence of
459
(lineno, insert, deletes, text)
460
for each literal line.
461
"""
462
463
istack = []
464
dset = set()
465
466
lineno = 0 # line of weave, 0-based
467
468
for l in self._weave:
469
if isinstance(l, tuple):
470
c, v = l
471
isactive = None
472
if c == '{':
473
istack.append(v)
474
elif c == '}':
475
istack.pop()
476
elif c == '[':
477
assert v not in dset
478
dset.add(v)
479
elif c == ']':
480
dset.remove(v)
481
else:
482
raise WeaveFormatError('unexpected instruction %r'
483
% v)
484
else:
485
assert isinstance(l, basestring)
486
assert istack
487
yield lineno, istack[-1], dset, l
488
lineno += 1
489
490
491
492
def _extract(self, versions):
493
"""Yield annotation of lines in included set.
494
495
Yields a sequence of tuples (origin, lineno, text), where
496
origin is the origin version, lineno the index in the weave,
497
and text the text of the line.
498
499
The set typically but not necessarily corresponds to a version.
500
"""
501
for i in versions:
502
if not isinstance(i, int):
503
raise ValueError(i)
504
505
included = self.inclusions(versions)
506
507
istack = []
508
dset = set()
509
510
lineno = 0 # line of weave, 0-based
511
512
isactive = None
513
514
result = []
515
516
WFE = WeaveFormatError
517
518
for l in self._weave:
519
if isinstance(l, tuple):
520
c, v = l
521
isactive = None
522
if c == '{':
523
assert v not in istack
524
istack.append(v)
525
elif c == '}':
526
istack.pop()
527
elif c == '[':
528
if v in included:
529
assert v not in dset
530
dset.add(v)
531
else:
532
assert c == ']'
533
if v in included:
534
assert v in dset
535
dset.remove(v)
536
else:
537
assert isinstance(l, basestring)
538
if isactive is None:
539
isactive = (not dset) and istack and (istack[-1] in included)
540
if isactive:
541
result.append((istack[-1], lineno, l))
542
lineno += 1
543
544
if istack:
545
raise WFE("unclosed insertion blocks at end of weave",
546
istack)
547
if dset:
548
raise WFE("unclosed deletion blocks at end of weave",
549
dset)
550
551
return result
552
553
554
555
def get_iter(self, name_or_index):
556
"""Yield lines for the specified version."""
557
incls = [self.maybe_lookup(name_or_index)]
558
for origin, lineno, line in self._extract(incls):
559
yield line
560
561
562
def get_text(self, name_or_index):
563
return ''.join(self.get_iter(name_or_index))
564
assert isinstance(version, int)
565
566
567
def get_lines(self, name_or_index):
568
return list(self.get_iter(name_or_index))
569
570
571
get = get_lines
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