~bzr-pqm/bzr/bzr.dev : revision 944

113

the version-id is used to reference it in the larger world.

114

115

The weave is represented as a list mixing edit instructions and

116

literal text. Each entry in _l can be either a string (or

116

literal text. Each entry in _weave can be either a string (or

117

unicode), or a tuple. If a string, it means that the given line

118

should be output in the currently active revisions.

119

157

should be no way to get an earlier version deleting a later

158

version.

159

160

_l

161

Text of the weave.

160

_weave

161

Text of the weave; list of control instruction tuples and strings.

162

163

_v

163

_parents

164

List of parents, indexed by version number.

165

It is only necessary to store the minimal set of parents for

166

each version; the parent's parents are implied.

169

List of hex SHA-1 of each version, or None if not recorded.

170

"""

171

172

__slots__ = ['_l', '_v', '_sha1s']

172

__slots__ = ['_weave', '_parents', '_sha1s']

173

174

def __init__(self):

175

self._l = []

176

self._v = []

175

self._weave = []

176

self._parents = []

177

self._sha1s = []

178

179

180

def __eq__(self, other):

181

if not isinstance(other, Weave):

182

return False

183

return self._v == other._v \

184

and self._l == other._l

183

return self._parents == other._parents \

184

and self._weave == other._weave

185

186

187

def __ne__(self, other):

201

202

self._check_versions(parents)

203

## self._check_lines(text)

204

new_version = len(self._v)

204

new_version = len(self._parents)

205

206

import sha

207

s = sha.new()

210

del s

211

212

# if we abort after here the weave will be corrupt

213

self._v.append(frozenset(parents))

213

self._parents.append(frozenset(parents))

214

self._sha1s.append(sha1)

215

216

220

# even more specially, if we're adding an empty text we

221

# need do nothing at all.

222

if text:

223

self._l.append(('{', new_version))

224

self._l.extend(text)

225

self._l.append(('}', new_version))

223

self._weave.append(('{', new_version))

224

self._weave.extend(text)

225

self._weave.append(('}', new_version))

226

227

return new_version

228

235

236

ancestors = self.inclusions(parents)

237

238

l = self._l

238

l = self._weave

239

240

# basis a list of (origin, lineno, line)

241

basis_lineno = []

249

return new_version

250

251

# add a sentinal, because we can also match against the final line

252

basis_lineno.append(len(self._l))

252

basis_lineno.append(len(self._weave))

253

254

# XXX: which line of the weave should we really consider

255

# matches the end of the file? the current code says it's the

283

# the deletion and insertion are handled separately.

284

# first delete the region.

285

if i1 != i2:

286

self._l.insert(i1+offset, ('[', new_version))

287

self._l.insert(i2+offset+1, (']', new_version))

286

self._weave.insert(i1+offset, ('[', new_version))

287

self._weave.insert(i2+offset+1, (']', new_version))

288

offset += 2

289

290

if j1 != j2:

292

# i2; we want to insert after this region to make sure

293

# we don't destroy ourselves

294

i = i2 + offset

295

self._l[i:i] = ([('{', new_version)]

295

self._weave[i:i] = ([('{', new_version)]

296

+ text[j1:j2]

297

+ [('}', new_version)])

298

offset += 2 + (j2 - j1)

308

while v >= 0:

309

if v in i:

310

# include all its parents

311

i.update(self._v[v])

311

i.update(self._parents[v])

312

v -= 1

313

return i

314

except IndexError:

317

318

def minimal_parents(self, version):

319

"""Find the minimal set of parents for the version."""

320

included = self._v[version]

320

included = self._parents[version]

321

if not included:

322

return []

323

353

"""Check everything in the sequence of indexes is valid"""

354

for i in indexes:

355

try:

356

self._v[i]

356

self._parents[i]

357

except IndexError:

358

raise IndexError("invalid version number %r" % i)

359

383

384

lineno = 0 # line of weave, 0-based

385

386

for l in self._l:

386

for l in self._weave:

387

if isinstance(l, tuple):

388

c, v = l

389

isactive = None

429

430

WFE = WeaveFormatError

431

432

for l in self._l:

432

for l in self._weave:

433

if isinstance(l, tuple):

434

c, v = l

435

isactive = None

485

486

def dump(self, to_file):

487

from pprint import pprint

488

print >>to_file, "Weave._l = ",

489

pprint(self._l, to_file)

490

print >>to_file, "Weave._v = ",

491

pprint(self._v, to_file)

488

print >>to_file, "Weave._weave = ",

489

pprint(self._weave, to_file)

490

print >>to_file, "Weave._parents = ",

491

pprint(self._parents, to_file)

492

493

494

495

def numversions(self):

496

l = len(self._v)

496

l = len(self._parents)

497

assert l == len(self._sha1s)

498

return l

499

501

def check(self, progress_bar=None):

502

# check no circular inclusions

503

for version in range(self.numversions()):

504

inclusions = list(self._v[version])

504

inclusions = list(self._parents[version])

505

if inclusions:

506

inclusions.sort()

507

if inclusions[-1] >= version:

680

# FIXME: doesn't work on pipes

681

weave_size = wf.tell()

682

print >>out, "weave file size %d bytes" % weave_size

683

print >>out, "weave contains %d versions" % len(w._v)

683

print >>out, "weave contains %d versions" % len(w._parents)

684

685

total = 0

686

print '%6s %6s %8s %40s %20s' % ('ver', 'lines', 'bytes', 'sha1', 'parents')

687

for i in (6, 6, 8, 40, 20):

688

print '-' * i,

689

print

690

for i in range(len(w._v)):

690

for i in range(len(w._parents)):

691

text = w.get(i)

692

lines = len(text)

693

bytes = sum((len(a) for a in text))

694

sha1 = w._sha1s[i]

695

print '%6d %6d %8d %40s' % (i, lines, bytes, sha1),

696

for pv in w._v[i]:

696

for pv in w._parents[i]:

697

print pv,

698

print

699

total += bytes

818

819

elif cmd == 'parents':

820

w = readit()

821

print ' '.join(map(str, w._v[int(argv[3])]))

821

print ' '.join(map(str, w._parents[int(argv[3])]))

822

823

elif cmd == 'plan-merge':

824

w = readit()