3
# Copyright (C) 2005 Canonical Ltd
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.
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.
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
19
# Author: Martin Pool <mbp@canonical.com>
22
"""Weave - storage of related text file versions"""
25
# XXX: If we do weaves this way, will a merge still behave the same
26
# way if it's done in a different order? That's a pretty desirable
29
# TODO: Nothing here so far assumes the lines are really \n newlines,
30
# rather than being split up in some other way. We could accomodate
31
# binaries, perhaps by naively splitting on \n or perhaps using
32
# something like a rolling checksum.
34
# TODO: End marker for each version so we can stop reading?
36
# TODO: Check that no insertion occurs inside a deletion that was
37
# active in the version of the insertion.
39
# TODO: In addition to the SHA-1 check, perhaps have some code that
40
# checks structural constraints of the weave: ie that insertions are
41
# properly nested, that there is no text outside of an insertion, that
42
# insertions or deletions are not repeated, etc.
44
# TODO: Parallel-extract that passes back each line along with a
45
# description of which revisions include it. Nice for checking all
46
# shas or calculating stats in parallel.
48
# TODO: Using a single _extract routine and then processing the output
49
# is probably inefficient. It's simple enough that we can afford to
50
# have slight specializations for different ways its used: annotate,
51
# basis for add, get, etc.
53
# TODO: Probably the API should work only in names to hide the integer
54
# indexes from the user.
56
# TODO: Is there any potential performance win by having an add()
57
# variant that is passed a pre-cooked version of the single basis
60
# TODO: Reweave can possibly be made faster by remembering diffs
61
# where the basis and destination are unchanged.
63
# FIXME: Sometimes we will be given a parents list for a revision
64
# that includes some redundant parents (i.e. already a parent of
65
# something in the list.) We should eliminate them. This can
66
# be done fairly efficiently because the sequence numbers constrain
67
# the possible relationships.
71
from difflib import SequenceMatcher
73
from bzrlib.trace import mutter
74
from bzrlib.errors import WeaveError, WeaveFormatError, WeaveParentMismatch, \
75
WeaveRevisionNotPresent, WeaveRevisionAlreadyPresent
76
from bzrlib.tsort import topo_sort
80
"""weave - versioned text file storage.
82
A Weave manages versions of line-based text files, keeping track
83
of the originating version for each line.
85
To clients the "lines" of the file are represented as a list of strings.
86
These strings will typically have terminal newline characters, but
87
this is not required. In particular files commonly do not have a newline
88
at the end of the file.
90
Texts can be identified in either of two ways:
92
* a nonnegative index number.
94
* a version-id string.
96
Typically the index number will be valid only inside this weave and
97
the version-id is used to reference it in the larger world.
99
The weave is represented as a list mixing edit instructions and
100
literal text. Each entry in _weave can be either a string (or
101
unicode), or a tuple. If a string, it means that the given line
102
should be output in the currently active revisions.
104
If a tuple, it gives a processing instruction saying in which
105
revisions the enclosed lines are active. The tuple has the form
106
(instruction, version).
108
The instruction can be '{' or '}' for an insertion block, and '['
109
and ']' for a deletion block respectively. The version is the
110
integer version index. There is no replace operator, only deletes
111
and inserts. For '}', the end of an insertion, there is no
112
version parameter because it always closes the most recently
117
* A later version can delete lines that were introduced by any
118
number of ancestor versions; this implies that deletion
119
instructions can span insertion blocks without regard to the
120
insertion block's nesting.
122
* Similarly, deletions need not be properly nested with regard to
123
each other, because they might have been generated by
124
independent revisions.
126
* Insertions are always made by inserting a new bracketed block
127
into a single point in the previous weave. This implies they
128
can nest but not overlap, and the nesting must always have later
129
insertions on the inside.
131
* It doesn't seem very useful to have an active insertion
132
inside an inactive insertion, but it might happen.
134
* Therefore, all instructions are always"considered"; that
135
is passed onto and off the stack. An outer inactive block
136
doesn't disable an inner block.
138
* Lines are enabled if the most recent enclosing insertion is
139
active and none of the enclosing deletions are active.
141
* There is no point having a deletion directly inside its own
142
insertion; you might as well just not write it. And there
143
should be no way to get an earlier version deleting a later
147
Text of the weave; list of control instruction tuples and strings.
150
List of parents, indexed by version number.
151
It is only necessary to store the minimal set of parents for
152
each version; the parent's parents are implied.
155
List of hex SHA-1 of each version.
158
List of symbolic names for each version. Each should be unique.
161
For each name, the version number.
164
Descriptive name of this weave; typically the filename if known.
168
__slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
171
def __init__(self, weave_name=None):
177
self._weave_name = weave_name
181
"""Return a deep copy of self.
183
The copy can be modified without affecting the original weave."""
185
other._weave = self._weave[:]
186
other._parents = self._parents[:]
187
other._sha1s = self._sha1s[:]
188
other._names = self._names[:]
189
other._name_map = self._name_map.copy()
190
other._weave_name = self._weave_name
193
def __eq__(self, other):
194
if not isinstance(other, Weave):
196
return self._parents == other._parents \
197
and self._weave == other._weave \
198
and self._sha1s == other._sha1s
201
def __ne__(self, other):
202
return not self.__eq__(other)
205
def maybe_lookup(self, name_or_index):
206
"""Convert possible symbolic name to index, or pass through indexes."""
207
if isinstance(name_or_index, (int, long)):
210
return self.lookup(name_or_index)
213
def lookup(self, name):
214
"""Convert symbolic version name to index."""
216
return self._name_map[name]
218
raise WeaveRevisionNotPresent(name, self)
221
return self._names[:]
223
def iter_names(self):
224
"""Yield a list of all names in this weave."""
225
return iter(self._names)
227
def idx_to_name(self, version):
228
return self._names[version]
230
def _check_repeated_add(self, name, parents, text, sha1):
231
"""Check that a duplicated add is OK.
233
If it is, return the (old) index; otherwise raise an exception.
235
idx = self.lookup(name)
236
if sorted(self._parents[idx]) != sorted(parents) \
237
or sha1 != self._sha1s[idx]:
238
raise WeaveRevisionAlreadyPresent(name, self)
241
def add(self, name, parents, text, sha1=None):
242
"""Add a single text on top of the weave.
244
Returns the index number of the newly added version.
247
Symbolic name for this version.
248
(Typically the revision-id of the revision that added it.)
251
List or set of direct parent version numbers.
254
Sequence of lines to be added in the new version.
256
sha -- SHA-1 of the file, if known. This is trusted to be
259
from bzrlib.osutils import sha_strings
261
assert isinstance(name, basestring)
263
sha1 = sha_strings(text)
264
if name in self._name_map:
265
return self._check_repeated_add(name, parents, text, sha1)
267
parents = map(self.maybe_lookup, parents)
268
self._check_versions(parents)
269
## self._check_lines(text)
270
new_version = len(self._parents)
273
# if we abort after here the (in-memory) weave will be corrupt because only
274
# some fields are updated
275
self._parents.append(parents[:])
276
self._sha1s.append(sha1)
277
self._names.append(name)
278
self._name_map[name] = new_version
282
# special case; adding with no parents revision; can do
283
# this more quickly by just appending unconditionally.
284
# even more specially, if we're adding an empty text we
285
# need do nothing at all.
287
self._weave.append(('{', new_version))
288
self._weave.extend(text)
289
self._weave.append(('}', None))
293
if len(parents) == 1:
294
pv = list(parents)[0]
295
if sha1 == self._sha1s[pv]:
296
# special case: same as the single parent
300
ancestors = self.inclusions(parents)
304
# basis a list of (origin, lineno, line)
307
for origin, lineno, line in self._extract(ancestors):
308
basis_lineno.append(lineno)
309
basis_lines.append(line)
311
# another small special case: a merge, producing the same text
313
if text == basis_lines:
316
# add a sentinal, because we can also match against the final line
317
basis_lineno.append(len(self._weave))
319
# XXX: which line of the weave should we really consider
320
# matches the end of the file? the current code says it's the
321
# last line of the weave?
323
#print 'basis_lines:', basis_lines
324
#print 'new_lines: ', lines
326
s = SequenceMatcher(None, basis_lines, text)
328
# offset gives the number of lines that have been inserted
329
# into the weave up to the current point; if the original edit instruction
330
# says to change line A then we actually change (A+offset)
333
for tag, i1, i2, j1, j2 in s.get_opcodes():
334
# i1,i2 are given in offsets within basis_lines; we need to map them
335
# back to offsets within the entire weave
336
#print 'raw match', tag, i1, i2, j1, j2
340
i1 = basis_lineno[i1]
341
i2 = basis_lineno[i2]
343
assert 0 <= j1 <= j2 <= len(text)
345
#print tag, i1, i2, j1, j2
347
# the deletion and insertion are handled separately.
348
# first delete the region.
350
self._weave.insert(i1+offset, ('[', new_version))
351
self._weave.insert(i2+offset+1, (']', new_version))
355
# there may have been a deletion spanning up to
356
# i2; we want to insert after this region to make sure
357
# we don't destroy ourselves
359
self._weave[i:i] = ([('{', new_version)]
362
offset += 2 + (j2 - j1)
366
def add_identical(self, old_rev_id, new_rev_id, parents):
367
"""Add an identical text to old_rev_id as new_rev_id."""
368
old_lines = self.get(self.lookup(old_rev_id))
369
self.add(new_rev_id, parents, old_lines)
371
def inclusions(self, versions):
372
"""Return set of all ancestors of given version(s)."""
374
for v in xrange(max(versions), 0, -1):
376
# include all its parents
377
i.update(self._parents[v])
379
## except IndexError:
380
## raise ValueError("version %d not present in weave" % v)
383
def parents(self, version):
384
return self._parents[version]
387
def parent_names(self, version):
388
"""Return version names for parents of a version."""
389
return map(self.idx_to_name, self._parents[self.lookup(version)])
392
def minimal_parents(self, version):
393
"""Find the minimal set of parents for the version."""
394
included = self._parents[version]
399
li.sort(reverse=True)
407
gotit.update(self.inclusions(pv))
409
assert mininc[0] >= 0
410
assert mininc[-1] < version
415
def _check_lines(self, text):
416
if not isinstance(text, list):
417
raise ValueError("text should be a list, not %s" % type(text))
420
if not isinstance(l, basestring):
421
raise ValueError("text line should be a string or unicode, not %s"
426
def _check_versions(self, indexes):
427
"""Check everything in the sequence of indexes is valid"""
432
raise IndexError("invalid version number %r" % i)
435
def annotate(self, name_or_index):
436
return list(self.annotate_iter(name_or_index))
439
def annotate_iter(self, name_or_index):
440
"""Yield list of (index-id, line) pairs for the specified version.
442
The index indicates when the line originated in the weave."""
443
incls = [self.maybe_lookup(name_or_index)]
444
for origin, lineno, text in self._extract(incls):
451
(lineno, insert, deletes, text)
452
for each literal line.
458
lineno = 0 # line of weave, 0-based
460
for l in self._weave:
461
if isinstance(l, tuple):
474
raise WeaveFormatError('unexpected instruction %r' % v)
476
assert isinstance(l, basestring)
478
yield lineno, istack[-1], dset, l
483
def _extract(self, versions):
484
"""Yield annotation of lines in included set.
486
Yields a sequence of tuples (origin, lineno, text), where
487
origin is the origin version, lineno the index in the weave,
488
and text the text of the line.
490
The set typically but not necessarily corresponds to a version.
493
if not isinstance(i, int):
496
included = self.inclusions(versions)
501
lineno = 0 # line of weave, 0-based
507
WFE = WeaveFormatError
509
for l in self._weave:
510
if isinstance(l, tuple):
514
assert v not in istack
528
assert isinstance(l, basestring)
530
isactive = (not dset) and istack and (istack[-1] in included)
532
result.append((istack[-1], lineno, l))
535
raise WeaveFormatError("unclosed insertion blocks "
536
"at end of weave: %s" % istack)
538
raise WeaveFormatError("unclosed deletion blocks at end of weave: %s"
543
def get_iter(self, name_or_index):
544
"""Yield lines for the specified version."""
545
incls = [self.maybe_lookup(name_or_index)]
546
for origin, lineno, line in self._extract(incls):
550
def get_text(self, name_or_index):
551
return ''.join(self.get_iter(name_or_index))
552
assert isinstance(version, int)
555
def get_lines(self, name_or_index):
556
return list(self.get_iter(name_or_index))
562
def mash_iter(self, included):
563
"""Return composed version of multiple included versions."""
564
included = map(self.maybe_lookup, included)
565
for origin, lineno, text in self._extract(included):
569
def dump(self, to_file):
570
from pprint import pprint
571
print >>to_file, "Weave._weave = ",
572
pprint(self._weave, to_file)
573
print >>to_file, "Weave._parents = ",
574
pprint(self._parents, to_file)
578
def numversions(self):
579
l = len(self._parents)
580
assert l == len(self._sha1s)
585
return self.numversions()
588
def check(self, progress_bar=None):
589
# check no circular inclusions
590
for version in range(self.numversions()):
591
inclusions = list(self._parents[version])
594
if inclusions[-1] >= version:
595
raise WeaveFormatError("invalid included version %d for index %d"
596
% (inclusions[-1], version))
598
# try extracting all versions; this is a bit slow and parallel
599
# extraction could be used
600
nv = self.numversions()
601
for version in range(nv):
603
progress_bar.update('checking text', version, nv)
605
for l in self.get_iter(version):
608
expected = self._sha1s[version]
610
raise WeaveError("mismatched sha1 for version %d; "
611
"got %s, expected %s"
612
% (version, hd, expected))
614
# TODO: check insertions are properly nested, that there are
615
# no lines outside of insertion blocks, that deletions are
616
# properly paired, etc.
620
def merge(self, merge_versions):
621
"""Automerge and mark conflicts between versions.
623
This returns a sequence, each entry describing alternatives
624
for a chunk of the file. Each of the alternatives is given as
627
If there is a chunk of the file where there's no diagreement,
628
only one alternative is given.
630
# approach: find the included versions common to all the
632
raise NotImplementedError()
636
def _delta(self, included, lines):
637
"""Return changes from basis to new revision.
639
The old text for comparison is the union of included revisions.
641
This is used in inserting a new text.
643
Delta is returned as a sequence of
644
(weave1, weave2, newlines).
646
This indicates that weave1:weave2 of the old weave should be
647
replaced by the sequence of lines in newlines. Note that
648
these line numbers are positions in the total weave and don't
649
correspond to the lines in any extracted version, or even the
650
extracted union of included versions.
652
If line1=line2, this is a pure insert; if newlines=[] this is a
653
pure delete. (Similar to difflib.)
655
raise NotImplementedError()
658
def plan_merge(self, ver_a, ver_b):
659
"""Return pseudo-annotation indicating how the two versions merge.
661
This is computed between versions a and b and their common
664
Weave lines present in none of them are skipped entirely.
666
inc_a = self.inclusions([ver_a])
667
inc_b = self.inclusions([ver_b])
668
inc_c = inc_a & inc_b
670
for lineno, insert, deleteset, line in self._walk():
671
if deleteset & inc_c:
672
# killed in parent; can't be in either a or b
673
# not relevant to our work
674
yield 'killed-base', line
675
elif insert in inc_c:
676
# was inserted in base
677
killed_a = bool(deleteset & inc_a)
678
killed_b = bool(deleteset & inc_b)
679
if killed_a and killed_b:
680
yield 'killed-both', line
682
yield 'killed-a', line
684
yield 'killed-b', line
686
yield 'unchanged', line
687
elif insert in inc_a:
688
if deleteset & inc_a:
689
yield 'ghost-a', line
693
elif insert in inc_b:
694
if deleteset & inc_b:
695
yield 'ghost-b', line
699
# not in either revision
700
yield 'irrelevant', line
702
yield 'unchanged', '' # terminator
706
def weave_merge(self, plan):
711
for state, line in plan:
712
if state == 'unchanged' or state == 'killed-both':
713
# resync and flush queued conflicts changes if any
714
if not lines_a and not lines_b:
716
elif ch_a and not ch_b:
718
for l in lines_a: yield l
719
elif ch_b and not ch_a:
720
for l in lines_b: yield l
721
elif lines_a == lines_b:
722
for l in lines_a: yield l
725
for l in lines_a: yield l
727
for l in lines_b: yield l
734
if state == 'unchanged':
737
elif state == 'killed-a':
740
elif state == 'killed-b':
743
elif state == 'new-a':
746
elif state == 'new-b':
750
assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
755
def join(self, other):
756
"""Integrate versions from other into this weave.
758
The resulting weave contains all the history of both weaves;
759
any version you could retrieve from either self or other can be
760
retrieved from self after this call.
762
It is illegal for the two weaves to contain different values
763
or different parents for any version. See also reweave().
765
if other.numversions() == 0:
766
return # nothing to update, easy
767
# two loops so that we do not change ourselves before verifying it
769
# work through in index order to make sure we get all dependencies
770
for other_idx, name in enumerate(other._names):
771
if self._check_version_consistent(other, other_idx, name):
773
for other_idx, name in enumerate(other._names):
774
# TODO: If all the parents of the other version are already
775
# present then we can avoid some work by just taking the delta
776
# and adjusting the offsets.
777
new_parents = self._imported_parents(other, other_idx)
778
lines = other.get_lines(other_idx)
779
sha1 = other._sha1s[other_idx]
780
self.add(name, new_parents, lines, sha1)
783
def _imported_parents(self, other, other_idx):
784
"""Return list of parents in self corresponding to indexes in other."""
786
for parent_idx in other._parents[other_idx]:
787
parent_name = other._names[parent_idx]
788
if parent_name not in self._names:
789
# should not be possible
790
raise WeaveError("missing parent {%s} of {%s} in %r"
791
% (parent_name, other._name_map[other_idx], self))
792
new_parents.append(self._name_map[parent_name])
795
def _check_version_consistent(self, other, other_idx, name):
796
"""Check if a version in consistent in this and other.
798
To be consistent it must have:
801
* the same direct parents (by name, not index, and disregarding
804
If present & correct return True;
805
if not present in self return False;
806
if inconsistent raise error."""
807
this_idx = self._name_map.get(name, -1)
809
if self._sha1s[this_idx] != other._sha1s[other_idx]:
810
raise WeaveError("inconsistent texts for version {%s} "
811
"when joining weaves"
813
self_parents = self._parents[this_idx]
814
other_parents = other._parents[other_idx]
815
n1 = [self._names[i] for i in self_parents]
816
n2 = [other._names[i] for i in other_parents]
820
raise WeaveParentMismatch("inconsistent parents "
821
"for version {%s}: %s vs %s" % (name, n1, n2))
827
def reweave(self, other):
828
"""Reweave self with other."""
829
new_weave = reweave(self, other)
830
for attr in self.__slots__:
831
setattr(self, attr, getattr(new_weave, attr))
835
"""Combine two weaves and return the result.
837
This works even if a revision R has different parents in
838
wa and wb. In the resulting weave all the parents are given.
840
This is done by just building up a new weave, maintaining ordering
841
of the versions in the two inputs. More efficient approaches
842
might be possible but it should only be necessary to do
843
this operation rarely, when a new previously ghost version is
848
queue_a = range(wa.numversions())
849
queue_b = range(wb.numversions())
850
# first determine combined parents of all versions
851
# map from version name -> all parent names
852
combined_parents = _reweave_parent_graphs(wa, wb)
853
mutter("combined parents: %r", combined_parents)
854
order = topo_sort(combined_parents.iteritems())
855
mutter("order to reweave: %r", order)
857
if name in wa._name_map:
858
lines = wa.get_lines(name)
859
if name in wb._name_map:
860
assert lines == wb.get_lines(name)
862
lines = wb.get_lines(name)
863
wr.add(name, combined_parents[name], lines)
867
def _reweave_parent_graphs(wa, wb):
868
"""Return combined parent ancestry for two weaves.
870
Returned as a list of (version_name, set(parent_names))"""
872
for weave in [wa, wb]:
873
for idx, name in enumerate(weave._names):
874
p = combined.setdefault(name, set())
875
p.update(map(weave.idx_to_name, weave._parents[idx]))
880
"""Show the weave's table-of-contents"""
881
print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
882
for i in (6, 50, 10, 10):
885
for i in range(w.numversions()):
888
parent_str = ' '.join(map(str, w._parents[i]))
889
print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
893
def weave_stats(weave_file, pb):
894
from bzrlib.weavefile import read_weave
896
wf = file(weave_file, 'rb')
898
# FIXME: doesn't work on pipes
899
weave_size = wf.tell()
903
for i in range(vers):
904
pb.update('checking sizes', i, vers)
905
for origin, lineno, line in w._extract([i]):
910
print 'versions %9d' % vers
911
print 'weave file %9d bytes' % weave_size
912
print 'total contents %9d bytes' % total
913
print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
916
print 'average size %9d bytes' % avg
917
print 'relative size %9.2fx' % (float(weave_size) / float(avg))
921
print """bzr weave tool
923
Experimental tool for weave algorithm.
927
Create an empty weave file
928
weave get WEAVEFILE VERSION
929
Write out specified version.
930
weave check WEAVEFILE
931
Check consistency of all versions.
933
Display table of contents.
934
weave add WEAVEFILE NAME [BASE...] < NEWTEXT
935
Add NEWTEXT, with specified parent versions.
936
weave annotate WEAVEFILE VERSION
937
Display origin of each line.
938
weave mash WEAVEFILE VERSION...
939
Display composite of all selected versions.
940
weave merge WEAVEFILE VERSION1 VERSION2 > OUT
941
Auto-merge two versions and display conflicts.
942
weave diff WEAVEFILE VERSION1 VERSION2
943
Show differences between two versions.
947
% weave init foo.weave
949
% weave add foo.weave ver0 < foo.txt
952
(create updated version)
954
% weave get foo.weave 0 | diff -u - foo.txt
955
% weave add foo.weave ver1 0 < foo.txt
958
% weave get foo.weave 0 > foo.txt (create forked version)
960
% weave add foo.weave ver2 0 < foo.txt
963
% weave merge foo.weave 1 2 > foo.txt (merge them)
964
% vi foo.txt (resolve conflicts)
965
% weave add foo.weave merged 1 2 < foo.txt (commit merged version)
977
# in case we're run directly from the subdirectory
978
sys.path.append('..')
980
from bzrlib.weavefile import write_weave, read_weave
981
from bzrlib.progress import ProgressBar
996
return read_weave(file(argv[2], 'rb'))
1002
# at the moment, based on everything in the file
1004
parents = map(int, argv[4:])
1005
lines = sys.stdin.readlines()
1006
ver = w.add(name, parents, lines)
1007
write_weave(w, file(argv[2], 'wb'))
1008
print 'added version %r %d' % (name, ver)
1011
if os.path.exists(fn):
1012
raise IOError("file exists")
1014
write_weave(w, file(fn, 'wb'))
1015
elif cmd == 'get': # get one version
1017
sys.stdout.writelines(w.get_iter(int(argv[3])))
1019
elif cmd == 'mash': # get composite
1021
sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
1024
from difflib import unified_diff
1027
v1, v2 = map(int, argv[3:5])
1030
diff_gen = unified_diff(lines1, lines2,
1031
'%s version %d' % (fn, v1),
1032
'%s version %d' % (fn, v2))
1033
sys.stdout.writelines(diff_gen)
1035
elif cmd == 'annotate':
1037
# newline is added to all lines regardless; too hard to get
1038
# reasonable formatting otherwise
1040
for origin, text in w.annotate(int(argv[3])):
1041
text = text.rstrip('\r\n')
1043
print ' | %s' % (text)
1045
print '%5d | %s' % (origin, text)
1051
elif cmd == 'stats':
1052
weave_stats(argv[2], ProgressBar())
1054
elif cmd == 'check':
1059
print '%d versions ok' % w.numversions()
1061
elif cmd == 'inclusions':
1063
print ' '.join(map(str, w.inclusions([int(argv[3])])))
1065
elif cmd == 'parents':
1067
print ' '.join(map(str, w._parents[int(argv[3])]))
1069
elif cmd == 'plan-merge':
1071
for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
1073
print '%14s | %s' % (state, line),
1075
elif cmd == 'merge':
1077
p = w.plan_merge(int(argv[3]), int(argv[4]))
1078
sys.stdout.writelines(w.weave_merge(p))
1080
elif cmd == 'mash-merge':
1086
v1, v2 = map(int, argv[3:5])
1088
basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
1090
base_lines = list(w.mash_iter(basis))
1091
a_lines = list(w.get(v1))
1092
b_lines = list(w.get(v2))
1094
from bzrlib.merge3 import Merge3
1095
m3 = Merge3(base_lines, a_lines, b_lines)
1097
name_a = 'version %d' % v1
1098
name_b = 'version %d' % v2
1099
sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
1101
raise ValueError('unknown command %r' % cmd)
1105
def profile_main(argv):
1106
import tempfile, hotshot, hotshot.stats
1108
prof_f = tempfile.NamedTemporaryFile()
1110
prof = hotshot.Profile(prof_f.name)
1112
ret = prof.runcall(main, argv)
1115
stats = hotshot.stats.load(prof_f.name)
1117
stats.sort_stats('cumulative')
1118
## XXX: Might like to write to stderr or the trace file instead but
1119
## print_stats seems hardcoded to stdout
1120
stats.print_stats(20)
1125
if __name__ == '__main__':
1127
if '--profile' in sys.argv:
1129
args.remove('--profile')
1130
sys.exit(profile_main(args))
1132
sys.exit(main(sys.argv))
added
removed
bzrlib/weave.py
