« back to all changes in this revision
Viewing changes to bzrlib/weave.py
- browse files at revision 170
- compare with another revision
- download diff
- download tarball
- view history from revision 170
- Committer: mbp at sourcefrog
- Date: 2005-04-05 08:24:51 UTC
- Revision ID: mbp@sourcefrog.net-20050405082451-408ebb0fd108440f
start adding quotes
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/util/elementtree/ => 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
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
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, pb):
788
from bzrlib.weavefile import read_weave
789
790
wf = file(weave_file, 'rb')
791
w = read_weave(wf)
792
# FIXME: doesn't work on pipes
793
weave_size = wf.tell()
794
795
total = 0
796
vers = len(w)
797
for i in range(vers):
798
pb.update('checking sizes', i, vers)
799
for line in w.get_iter(i):
800
total += len(line)
801
802
pb.clear()
803
804
print 'versions %9d' % vers
805
print 'weave file %9d bytes' % weave_size
806
print 'total contents %9d bytes' % total
807
print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
808
if vers:
809
avg = total/vers
810
print 'average size %9d bytes' % avg
811
print 'relative size %9.2fx' % (float(weave_size) / float(avg))
812
813
814
def usage():
815
print """bzr weave tool
816
817
Experimental tool for weave algorithm.
818
819
usage:
820
weave init WEAVEFILE
821
Create an empty weave file
822
weave get WEAVEFILE VERSION
823
Write out specified version.
824
weave check WEAVEFILE
825
Check consistency of all versions.
826
weave toc WEAVEFILE
827
Display table of contents.
828
weave add WEAVEFILE NAME [BASE...] < NEWTEXT
829
Add NEWTEXT, with specified parent versions.
830
weave annotate WEAVEFILE VERSION
831
Display origin of each line.
832
weave mash WEAVEFILE VERSION...
833
Display composite of all selected versions.
834
weave merge WEAVEFILE VERSION1 VERSION2 > OUT
835
Auto-merge two versions and display conflicts.
836
weave diff WEAVEFILE VERSION1 VERSION2
837
Show differences between two versions.
838
839
example:
840
841
% weave init foo.weave
842
% vi foo.txt
843
% weave add foo.weave ver0 < foo.txt
844
added version 0
845
846
(create updated version)
847
% vi foo.txt
848
% weave get foo.weave 0 | diff -u - foo.txt
849
% weave add foo.weave ver1 0 < foo.txt
850
added version 1
851
852
% weave get foo.weave 0 > foo.txt (create forked version)
853
% vi foo.txt
854
% weave add foo.weave ver2 0 < foo.txt
855
added version 2
856
857
% weave merge foo.weave 1 2 > foo.txt (merge them)
858
% vi foo.txt (resolve conflicts)
859
% weave add foo.weave merged 1 2 < foo.txt (commit merged version)
860
861
"""
862
863
864
865
def main(argv):
866
import sys
867
import os
868
try:
869
import bzrlib
870
except ImportError:
871
# in case we're run directly from the subdirectory
872
sys.path.append('..')
873
import bzrlib
874
from bzrlib.weavefile import write_weave, read_weave
875
from bzrlib.progress import ProgressBar
876
877
try:
878
import psyco
879
psyco.full()
880
except ImportError:
881
pass
882
883
if len(argv) < 2:
884
usage()
885
return 0
886
887
cmd = argv[1]
888
889
def readit():
890
return read_weave(file(argv[2], 'rb'))
891
892
if cmd == 'help':
893
usage()
894
elif cmd == 'add':
895
w = readit()
896
# at the moment, based on everything in the file
897
name = argv[3]
898
parents = map(int, argv[4:])
899
lines = sys.stdin.readlines()
900
ver = w.add(name, parents, lines)
901
write_weave(w, file(argv[2], 'wb'))
902
print 'added version %r %d' % (name, ver)
903
elif cmd == 'init':
904
fn = argv[2]
905
if os.path.exists(fn):
906
raise IOError("file exists")
907
w = Weave()
908
write_weave(w, file(fn, 'wb'))
909
elif cmd == 'get': # get one version
910
w = readit()
911
sys.stdout.writelines(w.get_iter(int(argv[3])))
912
913
elif cmd == 'mash': # get composite
914
w = readit()
915
sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
916
917
elif cmd == 'diff':
918
from difflib import unified_diff
919
w = readit()
920
fn = argv[2]
921
v1, v2 = map(int, argv[3:5])
922
lines1 = w.get(v1)
923
lines2 = w.get(v2)
924
diff_gen = unified_diff(lines1, lines2,
925
'%s version %d' % (fn, v1),
926
'%s version %d' % (fn, v2))
927
sys.stdout.writelines(diff_gen)
928
929
elif cmd == 'annotate':
930
w = readit()
931
# newline is added to all lines regardless; too hard to get
932
# reasonable formatting otherwise
933
lasto = None
934
for origin, text in w.annotate(int(argv[3])):
935
text = text.rstrip('\r\n')
936
if origin == lasto:
937
print ' | %s' % (text)
938
else:
939
print '%5d | %s' % (origin, text)
940
lasto = origin
941
942
elif cmd == 'toc':
943
weave_toc(readit())
944
945
elif cmd == 'stats':
946
weave_stats(argv[2], ProgressBar())
947
948
elif cmd == 'check':
949
w = readit()
950
pb = ProgressBar()
951
w.check(pb)
952
pb.clear()
953
print '%d versions ok' % w.numversions()
954
955
elif cmd == 'inclusions':
956
w = readit()
957
print ' '.join(map(str, w.inclusions([int(argv[3])])))
958
959
elif cmd == 'parents':
960
w = readit()
961
print ' '.join(map(str, w._parents[int(argv[3])]))
962
963
elif cmd == 'plan-merge':
964
w = readit()
965
for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
966
if line:
967
print '%14s | %s' % (state, line),
968
969
elif cmd == 'merge':
970
w = readit()
971
p = w.plan_merge(int(argv[3]), int(argv[4]))
972
sys.stdout.writelines(w.weave_merge(p))
973
974
elif cmd == 'mash-merge':
975
if len(argv) != 5:
976
usage()
977
return 1
978
979
w = readit()
980
v1, v2 = map(int, argv[3:5])
981
982
basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
983
984
base_lines = list(w.mash_iter(basis))
985
a_lines = list(w.get(v1))
986
b_lines = list(w.get(v2))
987
988
from bzrlib.merge3 import Merge3
989
m3 = Merge3(base_lines, a_lines, b_lines)
990
991
name_a = 'version %d' % v1
992
name_b = 'version %d' % v2
993
sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
994
else:
995
raise ValueError('unknown command %r' % cmd)
996
997
998
999
def profile_main(argv):
1000
import tempfile, hotshot, hotshot.stats
1001
1002
prof_f = tempfile.NamedTemporaryFile()
1003
1004
prof = hotshot.Profile(prof_f.name)
1005
1006
ret = prof.runcall(main, argv)
1007
prof.close()
1008
1009
stats = hotshot.stats.load(prof_f.name)
1010
#stats.strip_dirs()
1011
stats.sort_stats('cumulative')
1012
## XXX: Might like to write to stderr or the trace file instead but
1013
## print_stats seems hardcoded to stdout
1014
stats.print_stats(20)
1015
1016
return ret
1017
1018
1019
if __name__ == '__main__':
1020
import sys
1021
if '--profile' in sys.argv:
1022
args = sys.argv[:]
1023
args.remove('--profile')
1024
sys.exit(profile_main(args))
1025
else:
1026
sys.exit(main(sys.argv))
1027
Loggerhead is a web-based interface for Breezy
Version: 2.0.1