0.1.1
by Martin Pool
Check in old existing knit code. |
1 |
#! /usr/bin/python
|
2 |
||
3 |
# Copyright (C) 2005 Canonical Ltd
|
|
4 |
||
0.1.33
by Martin Pool
add gpl text |
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
|
|
0.1.1
by Martin Pool
Check in old existing knit code. |
18 |
|
19 |
# Author: Martin Pool <mbp@canonical.com>
|
|
20 |
||
21 |
||
0.1.38
by Martin Pool
Rename knit to weave. (I don't think there's an existing module called weave.) |
22 |
"""Weave - storage of related text file versions"""
|
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
23 |
|
928
by Martin Pool
- go back to using plain builtin set() |
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 |
||
931
by Martin Pool
- experiment with making Weave._extract() return a list, not a generator - slightly faster |
28 |
# making _extract build and return a list, rather than being a generator
|
29 |
# takes 37.94s
|
|
30 |
||
938
by Martin Pool
- various optimizations to weave add code |
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 |
||
1079
by Martin Pool
- weavefile can just use lists for read-in ancestry, not frozensets |
48 |
# with all this and simplification of add code, 33s
|
49 |
||
50 |
||
51 |
||
52 |
||
938
by Martin Pool
- various optimizations to weave add code |
53 |
|
0.1.61
by Martin Pool
doc |
54 |
# TODO: Perhaps have copy method for Weave instances?
|
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
55 |
|
0.1.58
by Martin Pool
doc |
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 |
||
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
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 |
||
0.1.85
by Martin Pool
doc |
65 |
# TODO: End marker for each version so we can stop reading?
|
0.1.69
by Martin Pool
Simple text-based format for storing weaves, cleaner than |
66 |
|
67 |
# TODO: Check that no insertion occurs inside a deletion that was
|
|
68 |
# active in the version of the insertion.
|
|
69 |
||
912
by Martin Pool
- update todos for weave |
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.
|
|
0.1.85
by Martin Pool
doc |
74 |
|
918
by Martin Pool
- start doing new weave-merge algorithm |
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 |
||
1082
by Martin Pool
- lift imports |
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 |
||
1083
by Martin Pool
- add space to store revision-id in weave files |
84 |
# TODO: Perhaps the API should work only in names to hide the integer
|
85 |
# indexes from the user?
|
|
86 |
||
1328
by Martin Pool
- slight refactoring of weave code |
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 |
||
1083
by Martin Pool
- add space to store revision-id in weave files |
91 |
|
1082
by Martin Pool
- lift imports |
92 |
|
93 |
import sha |
|
1322
by Martin Pool
- tidy up import |
94 |
from difflib import SequenceMatcher |
1237
by Martin Pool
- allow the same version to be repeatedly added to a weave |
95 |
|
0.1.85
by Martin Pool
doc |
96 |
|
1237
by Martin Pool
- allow the same version to be repeatedly added to a weave |
97 |
|
924
by Martin Pool
- Add IntSet class |
98 |
|
0.1.47
by Martin Pool
New WeaveError and WeaveFormatError rather than assertions. |
99 |
class WeaveError(Exception): |
100 |
"""Exception in processing weave"""
|
|
101 |
||
102 |
||
103 |
class WeaveFormatError(WeaveError): |
|
104 |
"""Weave invariant violated"""
|
|
105 |
||
106 |
||
0.1.38
by Martin Pool
Rename knit to weave. (I don't think there's an existing module called weave.) |
107 |
class Weave(object): |
108 |
"""weave - versioned text file storage.
|
|
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
109 |
|
0.1.72
by Martin Pool
Go back to weave lines normally having newlines at the end. |
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.
|
|
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
117 |
|
0.1.4
by Martin Pool
Start indexing knits by both integer and version string. |
118 |
Texts can be identified in either of two ways:
|
119 |
||
120 |
* a nonnegative index number.
|
|
121 |
||
1324
by Martin Pool
- doc |
122 |
* a version-id string.
|
0.1.4
by Martin Pool
Start indexing knits by both integer and version string. |
123 |
|
0.1.38
by Martin Pool
Rename knit to weave. (I don't think there's an existing module called weave.) |
124 |
Typically the index number will be valid only inside this weave and
|
0.1.4
by Martin Pool
Start indexing knits by both integer and version string. |
125 |
the version-id is used to reference it in the larger world.
|
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
126 |
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
127 |
The weave is represented as a list mixing edit instructions and
|
944
by Martin Pool
- refactor member names in Weave code |
128 |
literal text. Each entry in _weave can be either a string (or
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
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
|
|
0.1.45
by Martin Pool
doc |
138 |
integer version index. There is no replace operator, only deletes
|
1075
by Martin Pool
- don't store redundant version number at end of insert blocks |
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.
|
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
142 |
|
0.1.41
by Martin Pool
Doc |
143 |
Constraints/notes:
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
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 |
||
0.1.41
by Martin Pool
Doc |
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 |
||
0.1.45
by Martin Pool
doc |
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 |
||
0.1.41
by Martin Pool
Doc |
159 |
* It doesn't seem very useful to have an active insertion
|
160 |
inside an inactive insertion, but it might happen.
|
|
0.1.45
by Martin Pool
doc |
161 |
|
0.1.41
by Martin Pool
Doc |
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.
|
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
168 |
|
0.1.49
by Martin Pool
Add another constraint: revisions should not delete text that they |
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 |
||
944
by Martin Pool
- refactor member names in Weave code |
174 |
_weave
|
175 |
Text of the weave; list of control instruction tuples and strings.
|
|
0.1.4
by Martin Pool
Start indexing knits by both integer and version string. |
176 |
|
944
by Martin Pool
- refactor member names in Weave code |
177 |
_parents
|
892
by Martin Pool
- weave stores only direct parents, and calculates and memoizes expansion as needed |
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.
|
|
0.1.13
by Martin Pool
Knit structure now allows for versions to include the lines present in other |
181 |
|
0.1.89
by Martin Pool
Store SHA1 in weave file for later verification |
182 |
_sha1s
|
1083
by Martin Pool
- add space to store revision-id in weave files |
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.
|
|
1209
by Martin Pool
- Add Weave._weave_name for debugging purposes |
190 |
|
191 |
_weave_name
|
|
192 |
Descriptive name of this weave; typically the filename if known.
|
|
193 |
Set by read_weave.
|
|
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
194 |
"""
|
938
by Martin Pool
- various optimizations to weave add code |
195 |
|
1209
by Martin Pool
- Add Weave._weave_name for debugging purposes |
196 |
__slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map', |
197 |
'_weave_name'] |
|
938
by Martin Pool
- various optimizations to weave add code |
198 |
|
1209
by Martin Pool
- Add Weave._weave_name for debugging purposes |
199 |
def __init__(self, weave_name=None): |
944
by Martin Pool
- refactor member names in Weave code |
200 |
self._weave = [] |
201 |
self._parents = [] |
|
0.1.89
by Martin Pool
Store SHA1 in weave file for later verification |
202 |
self._sha1s = [] |
1083
by Martin Pool
- add space to store revision-id in weave files |
203 |
self._names = [] |
204 |
self._name_map = {} |
|
1209
by Martin Pool
- Add Weave._weave_name for debugging purposes |
205 |
self._weave_name = weave_name |
0.1.60
by Martin Pool
Weave eq and ne methods |
206 |
|
207 |
||
208 |
def __eq__(self, other): |
|
209 |
if not isinstance(other, Weave): |
|
210 |
return False |
|
944
by Martin Pool
- refactor member names in Weave code |
211 |
return self._parents == other._parents \ |
1083
by Martin Pool
- add space to store revision-id in weave files |
212 |
and self._weave == other._weave \ |
213 |
and self._sha1s == other._sha1s |
|
214 |
||
0.1.60
by Martin Pool
Weave eq and ne methods |
215 |
|
216 |
def __ne__(self, other): |
|
217 |
return not self.__eq__(other) |
|
218 |
||
1083
by Martin Pool
- add space to store revision-id in weave files |
219 |
|
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
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 |
||
1083
by Martin Pool
- add space to store revision-id in weave files |
228 |
def lookup(self, name): |
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
229 |
"""Convert symbolic version name to index."""
|
1083
by Martin Pool
- add space to store revision-id in weave files |
230 |
try: |
231 |
return self._name_map[name] |
|
232 |
except KeyError: |
|
1260
by Martin Pool
- some updates for fetch/update function |
233 |
raise WeaveError("name %r not present in weave %r" % |
1209
by Martin Pool
- Add Weave._weave_name for debugging purposes |
234 |
(name, self._weave_name)) |
1083
by Martin Pool
- add space to store revision-id in weave files |
235 |
|
1229
by Martin Pool
- new Weave.idx_to_name and .parents methods |
236 |
|
237 |
def idx_to_name(self, version): |
|
238 |
return self._names[version] |
|
239 |
||
1237
by Martin Pool
- allow the same version to be repeatedly added to a weave |
240 |
|
1323
by Martin Pool
- caller can pass SHA-1 to Weave.add for efficiency |
241 |
def _check_repeated_add(self, name, parents, text, sha1): |
1237
by Martin Pool
- allow the same version to be repeatedly added to a weave |
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) |
|
1323
by Martin Pool
- caller can pass SHA-1 to Weave.add for efficiency |
250 |
if sha1 != self._sha1s[idx]: |
1237
by Martin Pool
- allow the same version to be repeatedly added to a weave |
251 |
raise WeaveError("name \"%s\" already present in weave " |
252 |
"with different text" % name) |
|
253 |
return idx |
|
254 |
||
255 |
||
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
256 |
|
1323
by Martin Pool
- caller can pass SHA-1 to Weave.add for efficiency |
257 |
def add(self, name, parents, text, sha1=None): |
0.1.4
by Martin Pool
Start indexing knits by both integer and version string. |
258 |
"""Add a single text on top of the weave.
|
0.1.36
by Martin Pool
doc |
259 |
|
0.1.26
by Martin Pool
Refactor parameters to add command |
260 |
Returns the index number of the newly added version.
|
261 |
||
1083
by Martin Pool
- add space to store revision-id in weave files |
262 |
name
|
263 |
Symbolic name for this version.
|
|
264 |
(Typically the revision-id of the revision that added it.)
|
|
265 |
||
0.1.26
by Martin Pool
Refactor parameters to add command |
266 |
parents
|
892
by Martin Pool
- weave stores only direct parents, and calculates and memoizes expansion as needed |
267 |
List or set of direct parent version numbers.
|
268 |
|
|
0.1.26
by Martin Pool
Refactor parameters to add command |
269 |
text
|
1323
by Martin Pool
- caller can pass SHA-1 to Weave.add for efficiency |
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 |
"""
|
|
1393.1.4
by Martin Pool
- weave tool now finds bzrlib if it's not on the default path |
275 |
from bzrlib.osutils import sha_strings |
938
by Martin Pool
- various optimizations to weave add code |
276 |
|
1083
by Martin Pool
- add space to store revision-id in weave files |
277 |
assert isinstance(name, basestring) |
1323
by Martin Pool
- caller can pass SHA-1 to Weave.add for efficiency |
278 |
if sha1 is None: |
279 |
sha1 = sha_strings(text) |
|
1083
by Martin Pool
- add space to store revision-id in weave files |
280 |
if name in self._name_map: |
1323
by Martin Pool
- caller can pass SHA-1 to Weave.add for efficiency |
281 |
return self._check_repeated_add(name, parents, text, sha1) |
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
282 |
|
283 |
parents = map(self.maybe_lookup, parents) |
|
938
by Martin Pool
- various optimizations to weave add code |
284 |
self._check_versions(parents) |
0.1.82
by Martin Pool
Small weave optimizations |
285 |
## self._check_lines(text)
|
944
by Martin Pool
- refactor member names in Weave code |
286 |
new_version = len(self._parents) |
0.1.5
by Martin Pool
Add test for storing two text versions. |
287 |
|
0.1.89
by Martin Pool
Store SHA1 in weave file for later verification |
288 |
|
1083
by Martin Pool
- add space to store revision-id in weave files |
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[:]) |
|
0.1.89
by Martin Pool
Store SHA1 in weave file for later verification |
292 |
self._sha1s.append(sha1) |
1083
by Martin Pool
- add space to store revision-id in weave files |
293 |
self._names.append(name) |
294 |
self._name_map[name] = new_version |
|
938
by Martin Pool
- various optimizations to weave add code |
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: |
|
944
by Martin Pool
- refactor member names in Weave code |
303 |
self._weave.append(('{', new_version)) |
304 |
self._weave.extend(text) |
|
1075
by Martin Pool
- don't store redundant version number at end of insert blocks |
305 |
self._weave.append(('}', None)) |
938
by Martin Pool
- various optimizations to weave add code |
306 |
|
307 |
return new_version |
|
308 |
||
941
by Martin Pool
- allow for parents specified to Weave.add to be a set |
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 |
|
938
by Martin Pool
- various optimizations to weave add code |
314 |
|
315 |
||
316 |
ancestors = self.inclusions(parents) |
|
317 |
||
944
by Martin Pool
- refactor member names in Weave code |
318 |
l = self._weave |
938
by Martin Pool
- various optimizations to weave add code |
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 |
||
974.1.26
by aaron.bentley at utoronto
merged mbp@sourcefrog.net-20050817233101-0939da1cf91f2472 |
327 |
# another small special case: a merge, producing the same text
|
328 |
# as auto-merge
|
|
938
by Martin Pool
- various optimizations to weave add code |
329 |
if text == basis_lines: |
330 |
return new_version |
|
331 |
||
332 |
# add a sentinal, because we can also match against the final line
|
|
944
by Martin Pool
- refactor member names in Weave code |
333 |
basis_lineno.append(len(self._weave)) |
938
by Martin Pool
- various optimizations to weave add code |
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: |
|
944
by Martin Pool
- refactor member names in Weave code |
366 |
self._weave.insert(i1+offset, ('[', new_version)) |
367 |
self._weave.insert(i2+offset+1, (']', new_version)) |
|
938
by Martin Pool
- various optimizations to weave add code |
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 |
|
944
by Martin Pool
- refactor member names in Weave code |
375 |
self._weave[i:i] = ([('{', new_version)] |
1075
by Martin Pool
- don't store redundant version number at end of insert blocks |
376 |
+ text[j1:j2] |
377 |
+ [('}', None)]) |
|
938
by Martin Pool
- various optimizations to weave add code |
378 |
offset += 2 + (j2 - j1) |
379 |
||
380 |
return new_version |
|
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
381 |
|
0.1.27
by Martin Pool
Check that version numbers passed in are reasonable |
382 |
|
0.1.78
by Martin Pool
Rename Weave.get_included to inclusions and getiter to get_iter |
383 |
def inclusions(self, versions): |
893
by Martin Pool
- Refactor weave calculation of inclusions |
384 |
"""Return set of all ancestors of given version(s)."""
|
928
by Martin Pool
- go back to using plain builtin set() |
385 |
i = set(versions) |
1328
by Martin Pool
- slight refactoring of weave code |
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)
|
|
0.1.77
by Martin Pool
New Weave.get_included() does transitive expansion |
393 |
|
394 |
||
1229
by Martin Pool
- new Weave.idx_to_name and .parents methods |
395 |
def parents(self, version): |
396 |
return self._parents[version] |
|
397 |
||
398 |
||
890
by Martin Pool
- weave info should show minimal expression of parents |
399 |
def minimal_parents(self, version): |
400 |
"""Find the minimal set of parents for the version."""
|
|
944
by Martin Pool
- refactor member names in Weave code |
401 |
included = self._parents[version] |
890
by Martin Pool
- weave info should show minimal expression of parents |
402 |
if not included: |
403 |
return [] |
|
404 |
||
405 |
li = list(included) |
|
893
by Martin Pool
- Refactor weave calculation of inclusions |
406 |
li.sort(reverse=True) |
890
by Martin Pool
- weave info should show minimal expression of parents |
407 |
|
408 |
mininc = [] |
|
928
by Martin Pool
- go back to using plain builtin set() |
409 |
gotit = set() |
890
by Martin Pool
- weave info should show minimal expression of parents |
410 |
|
411 |
for pv in li: |
|
412 |
if pv not in gotit: |
|
413 |
mininc.append(pv) |
|
893
by Martin Pool
- Refactor weave calculation of inclusions |
414 |
gotit.update(self.inclusions(pv)) |
890
by Martin Pool
- weave info should show minimal expression of parents |
415 |
|
416 |
assert mininc[0] >= 0 |
|
417 |
assert mininc[-1] < version |
|
418 |
return mininc |
|
419 |
||
420 |
||
0.1.75
by Martin Pool
Remove VerInfo class; just store sets directly in the list of |
421 |
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
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): |
|
869
by Martin Pool
- more weave.py command line options |
428 |
raise ValueError("text line should be a string or unicode, not %s" |
429 |
% type(l)) |
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
430 |
|
431 |
||
432 |
||
0.1.27
by Martin Pool
Check that version numbers passed in are reasonable |
433 |
def _check_versions(self, indexes): |
434 |
"""Check everything in the sequence of indexes is valid"""
|
|
435 |
for i in indexes: |
|
436 |
try: |
|
944
by Martin Pool
- refactor member names in Weave code |
437 |
self._parents[i] |
0.1.27
by Martin Pool
Check that version numbers passed in are reasonable |
438 |
except IndexError: |
439 |
raise IndexError("invalid version number %r" % i) |
|
440 |
||
0.1.2
by Martin Pool
Import testsweet module adapted from bzr. |
441 |
|
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
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): |
|
0.1.7
by Martin Pool
Add trivial annotate text |
447 |
"""Yield list of (index-id, line) pairs for the specified version.
|
448 |
||
449 |
The index indicates when the line originated in the weave."""
|
|
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
450 |
incls = [self.maybe_lookup(name_or_index)] |
451 |
for origin, lineno, text in self._extract(incls): |
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
452 |
yield origin, text |
0.1.22
by Martin Pool
Calculate delta for new versions relative to a set of parent versions. |
453 |
|
454 |
||
918
by Martin Pool
- start doing new weave-merge algorithm |
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 = [] |
|
928
by Martin Pool
- go back to using plain builtin set() |
464 |
dset = set() |
918
by Martin Pool
- start doing new weave-merge algorithm |
465 |
|
466 |
lineno = 0 # line of weave, 0-based |
|
467 |
||
944
by Martin Pool
- refactor member names in Weave code |
468 |
for l in self._weave: |
918
by Martin Pool
- start doing new weave-merge algorithm |
469 |
if isinstance(l, tuple): |
470 |
c, v = l |
|
471 |
isactive = None |
|
472 |
if c == '{': |
|
473 |
istack.append(v) |
|
474 |
elif c == '}': |
|
1075
by Martin Pool
- don't store redundant version number at end of insert blocks |
475 |
istack.pop() |
918
by Martin Pool
- start doing new weave-merge algorithm |
476 |
elif c == '[': |
926
by Martin Pool
- update more weave code to use intsets |
477 |
assert v not in dset |
478 |
dset.add(v) |
|
918
by Martin Pool
- start doing new weave-merge algorithm |
479 |
elif c == ']': |
926
by Martin Pool
- update more weave code to use intsets |
480 |
dset.remove(v) |
918
by Martin Pool
- start doing new weave-merge algorithm |
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 |
||
893
by Martin Pool
- Refactor weave calculation of inclusions |
492 |
def _extract(self, versions): |
0.1.20
by Martin Pool
Factor out Knit.extract() method |
493 |
"""Yield annotation of lines in included set.
|
494 |
||
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
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 |
||
0.1.20
by Martin Pool
Factor out Knit.extract() method |
499 |
The set typically but not necessarily corresponds to a version.
|
500 |
"""
|
|
1196
by Martin Pool
- [WIP] retrieve historical texts from weaves |
501 |
for i in versions: |
502 |
if not isinstance(i, int): |
|
503 |
raise ValueError(i) |
|
504 |
||
893
by Martin Pool
- Refactor weave calculation of inclusions |
505 |
included = self.inclusions(versions) |
881
by Martin Pool
- faster weave extraction |
506 |
|
507 |
istack = [] |
|
928
by Martin Pool
- go back to using plain builtin set() |
508 |
dset = set() |
0.1.48
by Martin Pool
Basic parsing of delete instructions. |
509 |
|
510 |
lineno = 0 # line of weave, 0-based |
|
891
by Martin Pool
- fix up refactoring of weave |
511 |
|
894
by Martin Pool
- small optimization for weave extract |
512 |
isactive = None |
0.1.85
by Martin Pool
doc |
513 |
|
931
by Martin Pool
- experiment with making Weave._extract() return a list, not a generator - slightly faster |
514 |
result = [] |
515 |
||
0.1.63
by Martin Pool
Abbreviate WeaveFormatError in some code |
516 |
WFE = WeaveFormatError |
0.1.95
by Martin Pool
- preliminary merge conflict detection |
517 |
|
944
by Martin Pool
- refactor member names in Weave code |
518 |
for l in self._weave: |
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
519 |
if isinstance(l, tuple): |
520 |
c, v = l |
|
894
by Martin Pool
- small optimization for weave extract |
521 |
isactive = None |
891
by Martin Pool
- fix up refactoring of weave |
522 |
if c == '{': |
523 |
assert v not in istack |
|
524 |
istack.append(v) |
|
525 |
elif c == '}': |
|
1075
by Martin Pool
- don't store redundant version number at end of insert blocks |
526 |
istack.pop() |
891
by Martin Pool
- fix up refactoring of weave |
527 |
elif c == '[': |
528 |
if v in included: |
|
881
by Martin Pool
- faster weave extraction |
529 |
assert v not in dset |
0.1.48
by Martin Pool
Basic parsing of delete instructions. |
530 |
dset.add(v) |
891
by Martin Pool
- fix up refactoring of weave |
531 |
else: |
532 |
assert c == ']' |
|
533 |
if v in included: |
|
881
by Martin Pool
- faster weave extraction |
534 |
assert v in dset |
0.1.48
by Martin Pool
Basic parsing of delete instructions. |
535 |
dset.remove(v) |
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
536 |
else: |
537 |
assert isinstance(l, basestring) |
|
894
by Martin Pool
- small optimization for weave extract |
538 |
if isactive is None: |
539 |
isactive = (not dset) and istack and (istack[-1] in included) |
|
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
540 |
if isactive: |
931
by Martin Pool
- experiment with making Weave._extract() return a list, not a generator - slightly faster |
541 |
result.append((istack[-1], lineno, l)) |
0.1.39
by Martin Pool
Change to a more realistic weave structure which can represent insertions and |
542 |
lineno += 1 |
0.1.7
by Martin Pool
Add trivial annotate text |
543 |
|
0.1.46
by Martin Pool
More constraints on structure of weave, and checks that they work |
544 |
if istack: |
0.1.63
by Martin Pool
Abbreviate WeaveFormatError in some code |
545 |
raise WFE("unclosed insertion blocks at end of weave", |
0.1.47
by Martin Pool
New WeaveError and WeaveFormatError rather than assertions. |
546 |
istack) |
0.1.48
by Martin Pool
Basic parsing of delete instructions. |
547 |
if dset: |
0.1.63
by Martin Pool
Abbreviate WeaveFormatError in some code |
548 |
raise WFE("unclosed deletion blocks at end of weave", |
0.1.48
by Martin Pool
Basic parsing of delete instructions. |
549 |
dset) |
0.1.40
by Martin Pool
Add test for extracting from weave with nested insertions |
550 |
|
931
by Martin Pool
- experiment with making Weave._extract() return a list, not a generator - slightly faster |
551 |
return result |
552 |
||
553 |
||
0.1.7
by Martin Pool
Add trivial annotate text |
554 |
|
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
555 |
def get_iter(self, name_or_index): |
0.1.5
by Martin Pool
Add test for storing two text versions. |
556 |
"""Yield lines for the specified version."""
|
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
557 |
incls = [self.maybe_lookup(name_or_index)] |
558 |
for origin, lineno, line in self._extract(incls): |
|
0.1.8
by Martin Pool
Unify get/annotate code |
559 |
yield line |
0.1.5
by Martin Pool
Add test for storing two text versions. |
560 |
|
561 |
||
1369
by Martin Pool
- try to avoid redundant conversion of strings when retrieving from weaves |
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): |
|
1269
by Martin Pool
- some weave operations automatically look up symbolic names if supplied |
568 |
return list(self.get_iter(name_or_index)) |
0.1.1
by Martin Pool
Check in old existing knit code. |
569 |
|
570 |
||
1369
by Martin Pool
- try to avoid redundant conversion of strings when retrieving from weaves |
571 |
get = get_lines |
572 |
||
573 |
||
0.1.95
by Martin Pool
- preliminary merge conflict detection |
574 |
def mash_iter(self, included): |
0.1.65
by Martin Pool
Add Weave.merge_iter to get automerged lines |
575 |
"""Return composed version of multiple included versions."""
|
1338
by Martin Pool
- Weave.mash_iter optionally takes names rather than indexes |
576 |
included = map(self.maybe_lookup, included) |
893
by Martin Pool
- Refactor weave calculation of inclusions |
577 |
for origin, lineno, text in self._extract(included): |
0.1.65
by Martin Pool
Add Weave.merge_iter to get automerged lines |
578 |
yield text |
579 |
||
580 |
||
0.1.11
by Martin Pool
Add Knit.dump method |
581 |
def dump(self, to_file): |
582 |
from pprint import pprint |
|
944
by Martin Pool
- refactor member names in Weave code |
583 |
print >>to_file, "Weave._weave = ", |
584 |
pprint(self._weave, to_file) |
|
585 |
print >>to_file, "Weave._parents = ", |
|
586 |
pprint(self._parents, to_file) |
|
0.1.11
by Martin Pool
Add Knit.dump method |
587 |
|
588 |
||
0.1.91
by Martin Pool
Update Weave.check |
589 |
|
590 |
def numversions(self): |
|
944
by Martin Pool
- refactor member names in Weave code |
591 |
l = len(self._parents) |
0.1.91
by Martin Pool
Update Weave.check |
592 |
assert l == len(self._sha1s) |
593 |
return l |
|
594 |
||
595 |
||
946
by Martin Pool
- weave info only shows the weave headers, doesn't extract every version: |
596 |
def __len__(self): |
597 |
return self.numversions() |
|
598 |
||
599 |
||
894
by Martin Pool
- small optimization for weave extract |
600 |
def check(self, progress_bar=None): |
0.1.91
by Martin Pool
Update Weave.check |
601 |
# check no circular inclusions
|
602 |
for version in range(self.numversions()): |
|
944
by Martin Pool
- refactor member names in Weave code |
603 |
inclusions = list(self._parents[version]) |
0.1.91
by Martin Pool
Update Weave.check |
604 |
if inclusions: |
605 |
inclusions.sort() |
|
606 |
if inclusions[-1] >= version: |
|
0.1.47
by Martin Pool
New WeaveError and WeaveFormatError rather than assertions. |
607 |
raise WeaveFormatError("invalid included version %d for index %d" |
0.1.91
by Martin Pool
Update Weave.check |
608 |
% (inclusions[-1], version)) |
609 |
||
610 |
# try extracting all versions; this is a bit slow and parallel
|
|
611 |
# extraction could be used
|
|
894
by Martin Pool
- small optimization for weave extract |
612 |
nv = self.numversions() |
613 |
for version in range(nv): |
|
614 |
if progress_bar: |
|
615 |
progress_bar.update('checking text', version, nv) |
|
0.1.91
by Martin Pool
Update Weave.check |
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)) |
|
0.1.18
by Martin Pool
Better Knit.dump method |
625 |
|
881
by Martin Pool
- faster weave extraction |
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 |
||
0.1.13
by Martin Pool
Knit structure now allows for versions to include the lines present in other |
630 |
|
631 |
||
0.1.95
by Martin Pool
- preliminary merge conflict detection |
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 |
||
0.1.21
by Martin Pool
Start computing a delta to insert a new revision |
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.
|
|
0.1.22
by Martin Pool
Calculate delta for new versions relative to a set of parent versions. |
655 |
|
0.1.55
by Martin Pool
doc |
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
|
|
0.1.22
by Martin Pool
Calculate delta for new versions relative to a set of parent versions. |
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.)
|
|
0.1.21
by Martin Pool
Start computing a delta to insert a new revision |
667 |
"""
|
668 |
||
0.1.1
by Martin Pool
Check in old existing knit code. |
669 |
|
918
by Martin Pool
- start doing new weave-merge algorithm |
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 |
"""
|
|
926
by Martin Pool
- update more weave code to use intsets |
679 |
inc_a = self.inclusions([ver_a]) |
680 |
inc_b = self.inclusions([ver_b]) |
|
918
by Martin Pool
- start doing new weave-merge algorithm |
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 |
|
926
by Martin Pool
- update more weave code to use intsets |
688 |
elif insert in inc_c: |
918
by Martin Pool
- start doing new weave-merge algorithm |
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 |
|
926
by Martin Pool
- update more weave code to use intsets |
700 |
elif insert in inc_a: |
918
by Martin Pool
- start doing new weave-merge algorithm |
701 |
if deleteset & inc_a: |
702 |
yield 'ghost-a', line |
|
703 |
else: |
|
704 |
# new in A; not in B
|
|
705 |
yield 'new-a', line |
|
926
by Martin Pool
- update more weave code to use intsets |
706 |
elif insert in inc_b: |
918
by Martin Pool
- start doing new weave-merge algorithm |
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 |
||
919
by Martin Pool
- more development of weave-merge |
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: |
|
920
by Martin Pool
- add more test cases for weave_merge |
763 |
assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base', |
764 |
'killed-both'), \ |
|
919
by Martin Pool
- more development of weave-merge |
765 |
state
|
766 |
||
767 |
||
768 |
||
769 |
||
918
by Martin Pool
- start doing new weave-merge algorithm |
770 |
|
771 |
||
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
772 |
|
1081
by Martin Pool
- if weave tool is invoked with no arguments, show help |
773 |
def weave_toc(w): |
774 |
"""Show the weave's table-of-contents"""
|
|
1083
by Martin Pool
- add space to store revision-id in weave files |
775 |
print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents') |
776 |
for i in (6, 50, 10, 10): |
|
870
by Martin Pool
- better weave info display |
777 |
print '-' * i, |
778 |
print
|
|
946
by Martin Pool
- weave info only shows the weave headers, doesn't extract every version: |
779 |
for i in range(w.numversions()): |
0.1.91
by Martin Pool
Update Weave.check |
780 |
sha1 = w._sha1s[i] |
1083
by Martin Pool
- add space to store revision-id in weave files |
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) |
|
0.1.88
by Martin Pool
Add weave info command. |
784 |
|
869
by Martin Pool
- more weave.py command line options |
785 |
|
786 |
||
1393.1.4
by Martin Pool
- weave tool now finds bzrlib if it's not on the default path |
787 |
def weave_stats(weave_file, pb): |
947
by Martin Pool
- new 'weave stats' command |
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)) |
|
974.1.26
by aaron.bentley at utoronto
merged mbp@sourcefrog.net-20050817233101-0939da1cf91f2472 |
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)) |
|
947
by Martin Pool
- new 'weave stats' command |
812 |
|
813 |
||
869
by Martin Pool
- more weave.py command line options |
814 |
def usage(): |
871
by Martin Pool
- add command for merge-based weave |
815 |
print """bzr weave tool |
816 |
||
817 |
Experimental tool for weave algorithm.
|
|
818 |
||
869
by Martin Pool
- more weave.py command line options |
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.
|
|
1081
by Martin Pool
- if weave tool is invoked with no arguments, show help |
826 |
weave toc WEAVEFILE
|
869
by Martin Pool
- more weave.py command line options |
827 |
Display table of contents.
|
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
828 |
weave add WEAVEFILE NAME [BASE...] < NEWTEXT
|
869
by Martin Pool
- more weave.py command line options |
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.
|
|
1329
by Martin Pool
- add diff command to weave utility |
836 |
weave diff WEAVEFILE VERSION1 VERSION2
|
837 |
Show differences between two versions.
|
|
871
by Martin Pool
- add command for merge-based weave |
838 |
|
839 |
example:
|
|
840 |
||
841 |
% weave init foo.weave
|
|
842 |
% vi foo.txt
|
|
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
843 |
% weave add foo.weave ver0 < foo.txt
|
871
by Martin Pool
- add command for merge-based weave |
844 |
added version 0
|
845 |
||
846 |
(create updated version)
|
|
847 |
% vi foo.txt
|
|
848 |
% weave get foo.weave 0 | diff -u - foo.txt
|
|
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
849 |
% weave add foo.weave ver1 0 < foo.txt
|
871
by Martin Pool
- add command for merge-based weave |
850 |
added version 1
|
851 |
||
852 |
% weave get foo.weave 0 > foo.txt (create forked version)
|
|
853 |
% vi foo.txt
|
|
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
854 |
% weave add foo.weave ver2 0 < foo.txt
|
871
by Martin Pool
- add command for merge-based weave |
855 |
added version 2
|
856 |
||
857 |
% weave merge foo.weave 1 2 > foo.txt (merge them)
|
|
858 |
% vi foo.txt (resolve conflicts)
|
|
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
859 |
% weave add foo.weave merged 1 2 < foo.txt (commit merged version)
|
871
by Martin Pool
- add command for merge-based weave |
860 |
|
869
by Martin Pool
- more weave.py command line options |
861 |
"""
|
0.1.88
by Martin Pool
Add weave info command. |
862 |
|
863 |
||
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
864 |
|
865 |
def main(argv): |
|
866 |
import sys |
|
867 |
import os |
|
1393.1.4
by Martin Pool
- weave tool now finds bzrlib if it's not on the default path |
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 |
|
1336
by Martin Pool
- tidy up import |
874 |
from bzrlib.weavefile import write_weave, read_weave |
894
by Martin Pool
- small optimization for weave extract |
875 |
from bzrlib.progress import ProgressBar |
876 |
||
1078
by Martin Pool
- use psyco for weave if possible |
877 |
try: |
878 |
import psyco |
|
879 |
psyco.full() |
|
880 |
except ImportError: |
|
881 |
pass
|
|
894
by Martin Pool
- small optimization for weave extract |
882 |
|
1081
by Martin Pool
- if weave tool is invoked with no arguments, show help |
883 |
if len(argv) < 2: |
884 |
usage() |
|
885 |
return 0 |
|
886 |
||
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
887 |
cmd = argv[1] |
869
by Martin Pool
- more weave.py command line options |
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() |
|
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
896 |
# at the moment, based on everything in the file
|
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
897 |
name = argv[3] |
898 |
parents = map(int, argv[4:]) |
|
0.1.72
by Martin Pool
Go back to weave lines normally having newlines at the end. |
899 |
lines = sys.stdin.readlines() |
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
900 |
ver = w.add(name, parents, lines) |
869
by Martin Pool
- more weave.py command line options |
901 |
write_weave(w, file(argv[2], 'wb')) |
1084
by Martin Pool
- weave add command needs to take a symbolic name too |
902 |
print 'added version %r %d' % (name, ver) |
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
903 |
elif cmd == 'init': |
904 |
fn = argv[2] |
|
905 |
if os.path.exists(fn): |
|
906 |
raise IOError("file exists") |
|
907 |
w = Weave() |
|
869
by Martin Pool
- more weave.py command line options |
908 |
write_weave(w, file(fn, 'wb')) |
909 |
elif cmd == 'get': # get one version |
|
910 |
w = readit() |
|
0.1.94
by Martin Pool
Fix get_iter call |
911 |
sys.stdout.writelines(w.get_iter(int(argv[3]))) |
869
by Martin Pool
- more weave.py command line options |
912 |
|
913 |
elif cmd == 'mash': # get composite |
|
914 |
w = readit() |
|
915 |
sys.stdout.writelines(w.mash_iter(map(int, argv[3:]))) |
|
916 |
||
1329
by Martin Pool
- add diff command to weave utility |
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 |
||
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
929 |
elif cmd == 'annotate': |
869
by Martin Pool
- more weave.py command line options |
930 |
w = readit() |
0.1.72
by Martin Pool
Go back to weave lines normally having newlines at the end. |
931 |
# newline is added to all lines regardless; too hard to get
|
932 |
# reasonable formatting otherwise
|
|
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
933 |
lasto = None |
934 |
for origin, text in w.annotate(int(argv[3])): |
|
0.1.72
by Martin Pool
Go back to weave lines normally having newlines at the end. |
935 |
text = text.rstrip('\r\n') |
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
936 |
if origin == lasto: |
937 |
print ' | %s' % (text) |
|
938 |
else: |
|
939 |
print '%5d | %s' % (origin, text) |
|
940 |
lasto = origin |
|
871
by Martin Pool
- add command for merge-based weave |
941 |
|
1081
by Martin Pool
- if weave tool is invoked with no arguments, show help |
942 |
elif cmd == 'toc': |
943 |
weave_toc(readit()) |
|
947
by Martin Pool
- new 'weave stats' command |
944 |
|
945 |
elif cmd == 'stats': |
|
1393.1.4
by Martin Pool
- weave tool now finds bzrlib if it's not on the default path |
946 |
weave_stats(argv[2], ProgressBar()) |
871
by Martin Pool
- add command for merge-based weave |
947 |
|
0.1.91
by Martin Pool
Update Weave.check |
948 |
elif cmd == 'check': |
869
by Martin Pool
- more weave.py command line options |
949 |
w = readit() |
894
by Martin Pool
- small optimization for weave extract |
950 |
pb = ProgressBar() |
951 |
w.check(pb) |
|
952 |
pb.clear() |
|
938
by Martin Pool
- various optimizations to weave add code |
953 |
print '%d versions ok' % w.numversions() |
871
by Martin Pool
- add command for merge-based weave |
954 |
|
892
by Martin Pool
- weave stores only direct parents, and calculates and memoizes expansion as needed |
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() |
|
944
by Martin Pool
- refactor member names in Weave code |
961 |
print ' '.join(map(str, w._parents[int(argv[3])])) |
892
by Martin Pool
- weave stores only direct parents, and calculates and memoizes expansion as needed |
962 |
|
918
by Martin Pool
- start doing new weave-merge algorithm |
963 |
elif cmd == 'plan-merge': |
964 |
w = readit() |
|
965 |
for state, line in w.plan_merge(int(argv[3]), int(argv[4])): |
|
919
by Martin Pool
- more development of weave-merge |
966 |
if line: |
967 |
print '%14s | %s' % (state, line), |
|
918
by Martin Pool
- start doing new weave-merge algorithm |
968 |
|
871
by Martin Pool
- add command for merge-based weave |
969 |
elif cmd == 'merge': |
919
by Martin Pool
- more development of weave-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': |
|
871
by Martin Pool
- add command for merge-based weave |
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)) |
|
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
994 |
else: |
995 |
raise ValueError('unknown command %r' % cmd) |
|
996 |
||
997 |
||
1076
by Martin Pool
- add code to run weave utility under profiler |
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()
|
|
1079
by Martin Pool
- weavefile can just use lists for read-in ancestry, not frozensets |
1011 |
stats.sort_stats('cumulative') |
1076
by Martin Pool
- add code to run weave utility under profiler |
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 |
||
0.1.62
by Martin Pool
Lame command-line client for reading and writing weaves. |
1019 |
if __name__ == '__main__': |
1020 |
import sys |
|
1081
by Martin Pool
- if weave tool is invoked with no arguments, show help |
1021 |
if '--profile' in sys.argv: |
1078
by Martin Pool
- use psyco for weave if possible |
1022 |
args = sys.argv[:] |
1081
by Martin Pool
- if weave tool is invoked with no arguments, show help |
1023 |
args.remove('--profile') |
1078
by Martin Pool
- use psyco for weave if possible |
1024 |
sys.exit(profile_main(args)) |
1025 |
else: |
|
1026 |
sys.exit(main(sys.argv)) |
|
1076
by Martin Pool
- add code to run weave utility under profiler |
1027 |