/brz/remove-bazaar : revision 0.200.772

1

2

3

4

#

5

# This program is free software; you can redistribute it and/or modify

22

import stat

23

24

from bzrlib import (

25

bencode,

26

25

errors,

27

26

foreign,

27

osutils,

28

trace,

29

urlutils,

29

30

)

31

try:

32

from bzrlib import bencode

33

except ImportError:

34

from bzrlib.util import bencode

30

35

from bzrlib.inventory import (

31

36

ROOT_ID,

32

37

)

42

47

format_hg_metadata,

43

48

extract_hg_metadata,

44

49

)

45

from bzrlib.plugins.git.roundtrip import (

46

extract_bzr_metadata,

47

inject_bzr_metadata,

48

BzrGitRevisionMetadata,

49

deserialize_fileid_map,

50

serialize_fileid_map,

51

)

52

50

53

51

DEFAULT_FILE_MODE = stat.S_IFREG | 0644

54

52

69

67

elif file_id[i+1] == 's':

70

68

ret.append(" ")

71

69

else:

72

raise AssertionError("unknown escape character %s" %

73

file_id[i+1])

70

raise AssertionError("unknown escape character %s" % file_id[i+1])

74

71

i += 1

75

72

i += 1

76

73

return "".join(ret)

88

85

89

86

90

87

def warn_unusual_mode(commit, path, mode):

91

trace.mutter("Unusual file mode %o for %s in %s. Storing as revision "

92

"property. ", mode, path, commit)

88

trace.mutter("Unusual file mode %o for %s in %s. Storing as revision property. ",

89

mode, path, commit)

90

91

92

def squash_revision(target_repo, rev):

93

"""Remove characters that can't be stored from a revision, if necessary.

94

95

:param target_repo: Repository in which the revision will be stored

96

:param rev: Revision object, will be modified in-place

97

"""

98

if not getattr(target_repo._serializer, "squashes_xml_invalid_characters", True):

99

return

100

from bzrlib.xml_serializer import escape_invalid_chars

101

rev.message, num_escaped = escape_invalid_chars(rev.message)

102

if num_escaped:

103

warn_escaped(rev.foreign_revid, num_escaped)

104

if 'author' in rev.properties:

105

rev.properties['author'], num_escaped = escape_invalid_chars(

106

rev.properties['author'])

107

if num_escaped:

108

warn_escaped(rev.foreign_revid, num_escaped)

109

rev.committer, num_escaped = escape_invalid_chars(rev.committer)

110

if num_escaped:

111

warn_escaped(rev.foreign_revid, num_escaped)

93

112

94

113

95

114

class BzrGitMapping(foreign.VcsMapping):

96

115

"""Class that maps between Git and Bazaar semantics."""

97

116

experimental = False

98

117

99

BZR_FILE_IDS_FILE = None

100

101

BZR_DUMMY_FILE = None

102

103

118

def __init__(self):

104

119

super(BzrGitMapping, self).__init__(foreign_git)

105

120

106

121

def __eq__(self, other):

107

return (type(self) == type(other) and

122

return (type(self) == type(other) and

108

123

self.revid_prefix == other.revid_prefix)

109

124

110

125

@classmethod

111

126

def revision_id_foreign_to_bzr(cls, git_rev_id):

112

127

"""Convert a git revision id handle to a Bazaar revision id."""

113

from dulwich.protocol import ZERO_SHA

114

if git_rev_id == ZERO_SHA:

128

if git_rev_id == "0" * 40:

115

129

return NULL_REVISION

116

130

return "%s:%s" % (cls.revid_prefix, git_rev_id)

117

131

127

141

# We must just hope they are valid UTF-8..

128

142

if path == "":

129

143

return ROOT_ID

130

if type(path) is unicode:

131

path = path.encode("utf-8")

132

144

return escape_file_id(path)

133

145

134

def is_control_file(self, path):

135

return path in (self.BZR_FILE_IDS_FILE, self.BZR_DUMMY_FILE)

136

137

146

def parse_file_id(self, file_id):

138

147

if file_id == ROOT_ID:

139

148

return ""

140

149

return unescape_file_id(file_id)

141

150

142

def revid_as_refname(self, revid):

143

import urllib

144

return "refs/bzr/%s" % urllib.quote(revid)

145

146

151

def import_unusual_file_modes(self, rev, unusual_file_modes):

147

152

if unusual_file_modes:

148

ret = [(path, unusual_file_modes[path])

149

for path in sorted(unusual_file_modes.keys())]

153

ret = [(name, unusual_file_modes[name])

154

for name in sorted(unusual_file_modes.keys())]

150

155

rev.properties['file-modes'] = bencode.bencode(ret)

151

156

152

157

def export_unusual_file_modes(self, rev):

153

158

try:

154

file_modes = rev.properties['file-modes']

159

return dict([(self.generate_file_id(path), mode) for (path, mode) in bencode.bdecode(rev.properties['file-modes'].encode("utf-8"))])

155

160

except KeyError:

156

161

return {}

157

else:

158

return dict([(self.generate_file_id(path), mode) for (path, mode) in bencode.bdecode(file_modes.encode("utf-8"))])

159

162

160

163

def _generate_git_svn_metadata(self, rev, encoding):

161

164

try:

162

git_svn_id = rev.properties["git-svn-id"]

165

return "\ngit-svn-id: %s\n" % rev.properties["git-svn-id"].encode(encoding)

163

166

except KeyError:

164

167

return ""

165

else:

166

return "\ngit-svn-id: %s\n" % git_svn_id.encode(encoding)

167

168

169

def _generate_hg_message_tail(self, rev):

169

170

extra = {}

173

174

if name == 'hg:extra:branch':

174

175

branch = rev.properties['hg:extra:branch']

175

176

elif name.startswith('hg:extra'):

176

extra[name[len('hg:extra:'):]] = base64.b64decode(

177

rev.properties[name])

177

extra[name[len('hg:extra:'):]] = base64.b64decode(rev.properties[name])

178

elif name == 'hg:renames':

179

renames = bencode.bdecode(base64.b64decode(

180

rev.properties['hg:renames']))

179

renames = bencode.bdecode(base64.b64decode(rev.properties['hg:renames']))

181

180

# TODO: Export other properties as 'bzr:' extras?

182

181

ret = format_hg_metadata(renames, branch, extra)

183

182

assert isinstance(ret, str)

185

184

186

185

def _extract_git_svn_metadata(self, rev, message):

187

186

lines = message.split("\n")

188

if not (lines[-1] == "" and len(lines) >= 2 and lines[-2].startswith("git-svn-id:")):

187

if not (lines[-1] == "" and lines[-2].startswith("git-svn-id:")):

189

188

return message

190

189

git_svn_id = lines[-2].split(": ", 1)[1]

191

190

rev.properties['git-svn-id'] = git_svn_id

202

201

for name, value in extra.iteritems():

203

202

rev.properties['hg:extra:' + name] = base64.b64encode(value)

204

203

if renames:

205

rev.properties['hg:renames'] = base64.b64encode(bencode.bencode(

206

[(new, old) for (old, new) in renames.iteritems()]))

204

rev.properties['hg:renames'] = base64.b64encode(bencode.bencode([(new, old) for (old, new) in renames.iteritems()]))

207

205

return message

208

206

209

def _extract_bzr_metadata(self, rev, message):

210

(message, metadata) = extract_bzr_metadata(message)

211

return message, metadata

212

213

207

def _decode_commit_message(self, rev, message, encoding):

214

return message.decode(encoding), BzrGitRevisionMetadata()

208

return message.decode(encoding)

215

209

216

210

def _encode_commit_message(self, rev, message, encoding):

217

211

return message.encode(encoding)

218

212

219

def export_fileid_map(self, fileid_map):

220

"""Export a file id map to a fileid map.

221

222

:param fileid_map: File id map, mapping paths to file ids

223

:return: A Git blob object

224

"""

225

from dulwich.objects import Blob

226

b = Blob()

227

b.set_raw_chunks(serialize_fileid_map(fileid_map))

228

return b

229

230

def export_commit(self, rev, tree_sha, parent_lookup, roundtrip,

231

verifiers):

213

def export_commit(self, rev, tree_sha, parent_lookup):

232

214

"""Turn a Bazaar revision in to a Git commit

233

215

234

216

:param tree_sha: Tree sha for the commit

235

:param parent_lookup: Function for looking up the GIT sha equiv of a

236

bzr revision

237

:param roundtrip: Whether to store roundtripping information.

238

:param verifiers: Verifiers info

217

:param parent_lookup: Function for looking up the GIT sha equiv of a bzr revision

239

218

:return dulwich.objects.Commit represent the revision:

240

219

"""

241

220

from dulwich.objects import Commit

242

221

commit = Commit()

243

222

commit.tree = tree_sha

244

if roundtrip:

245

metadata = BzrGitRevisionMetadata()

246

metadata.verifiers = verifiers

247

else:

248

metadata = None

249

parents = []

250

223

for p in rev.parent_ids:

251

224

try:

252

225

git_p = parent_lookup(p)

253

226

except KeyError:

254

227

git_p = None

255

if metadata is not None:

256

metadata.explicit_parent_ids = rev.parent_ids

257

228

if git_p is not None:

258

229

assert len(git_p) == 40, "unexpected length for %r" % git_p

259

parents.append(git_p)

260

commit.parents = parents

230

commit.parents.append(git_p)

261

231

try:

262

232

encoding = rev.properties['git-explicit-encoding']

263

233

except KeyError:

272

242

commit.author_time = long(rev.properties['author-timestamp'])

273

243

else:

274

244

commit.author_time = commit.commit_time

275

commit._commit_timezone_neg_utc = "commit-timezone-neg-utc" in rev.properties

276

245

commit.commit_timezone = rev.timezone

277

commit._author_timezone_neg_utc = "author-timezone-neg-utc" in rev.properties

278

246

if 'author-timezone' in rev.properties:

279

247

commit.author_timezone = int(rev.properties['author-timezone'])

280

248

else:

281

249

commit.author_timezone = commit.commit_timezone

282

250

commit.message = self._encode_commit_message(rev, rev.message,

283

251

encoding)

284

assert type(commit.message) == str

285

if metadata is not None:

286

try:

287

mapping_registry.parse_revision_id(rev.revision_id)

288

except errors.InvalidRevisionId:

289

metadata.revision_id = rev.revision_id

290

mapping_properties = set(

291

['author', 'author-timezone', 'author-timezone-neg-utc',

292

'commit-timezone-neg-utc', 'git-implicit-encoding',

293

'git-explicit-encoding', 'author-timestamp', 'file-modes'])

294

for k, v in rev.properties.iteritems():

295

if not k in mapping_properties:

296

metadata.properties[k] = v

297

if self.roundtripping:

298

commit.message = inject_bzr_metadata(commit.message, metadata,

299

encoding)

300

assert type(commit.message) == str

301

252

return commit

302

253

303

def import_fileid_map(self, blob):

304

"""Convert a git file id map blob.

305

306

:param blob: Git blob object with fileid map

307

:return: Dictionary mapping paths to file ids

308

"""

309

return deserialize_fileid_map(blob.data)

310

311

def import_commit(self, commit, lookup_parent_revid):

254

def import_commit(self, commit):

312

255

"""Convert a git commit to a bzr revision.

313

256

314

:return: a `bzrlib.revision.Revision` object, foreign revid and a

315

testament sha1

257

:return: a `bzrlib.revision.Revision` object.

316

258

"""

317

259

if commit is None:

318

260

raise AssertionError("Commit object can't be None")

319

rev = ForeignRevision(commit.id, self,

320

self.revision_id_foreign_to_bzr(commit.id))

321

rev.parent_ids = tuple([lookup_parent_revid(p) for p in commit.parents])

322

rev.git_metadata = None

261

rev = ForeignRevision(commit.id, self, self.revision_id_foreign_to_bzr(commit.id))

262

rev.parent_ids = tuple([self.revision_id_foreign_to_bzr(p) for p in commit.parents])

323

263

def decode_using_encoding(rev, commit, encoding):

324

264

rev.committer = str(commit.committer).decode(encoding)

325

265

if commit.committer != commit.author:

326

266

rev.properties['author'] = str(commit.author).decode(encoding)

327

rev.message, rev.git_metadata = self._decode_commit_message(

328

rev, commit.message, encoding)

267

rev.message = self._decode_commit_message(rev, commit.message,

268

encoding)

329

269

if commit.encoding is not None:

330

270

rev.properties['git-explicit-encoding'] = commit.encoding

331

271

decode_using_encoding(rev, commit, commit.encoding)

342

282

if commit.commit_time != commit.author_time:

343

283

rev.properties['author-timestamp'] = str(commit.author_time)

344

284

if commit.commit_timezone != commit.author_timezone:

345

rev.properties['author-timezone'] = "%d" % commit.author_timezone

346

if commit._author_timezone_neg_utc:

347

rev.properties['author-timezone-neg-utc'] = ""

348

if commit._commit_timezone_neg_utc:

349

rev.properties['commit-timezone-neg-utc'] = ""

285

rev.properties['author-timezone'] = "%d" % (commit.author_timezone, )

350

286

rev.timestamp = commit.commit_time

351

287

rev.timezone = commit.commit_timezone

352

if rev.git_metadata is not None:

353

md = rev.git_metadata

354

roundtrip_revid = md.revision_id

355

if md.explicit_parent_ids:

356

rev.parent_ids = md.explicit_parent_ids

357

rev.properties.update(md.properties)

358

verifiers = md.verifiers

359

else:

360

roundtrip_revid = None

361

verifiers = {}

362

return rev, roundtrip_revid, verifiers

363

364

def get_fileid_map(self, lookup_object, tree_sha):

365

"""Obtain a fileid map for a particular tree.

366

367

:param lookup_object: Function for looking up an object

368

:param tree_sha: SHA of the root tree

369

:return: GitFileIdMap instance

370

"""

371

try:

372

file_id_map_sha = lookup_object(tree_sha)[self.BZR_FILE_IDS_FILE][1]

373

except KeyError:

374

file_ids = {}

375

else:

376

file_ids = self.import_fileid_map(lookup_object(file_id_map_sha))

377

return GitFileIdMap(file_ids, self)

288

return rev

378

289

379

290

380

291

class BzrGitMappingv1(BzrGitMapping):

388

299

class BzrGitMappingExperimental(BzrGitMappingv1):

389

300

revid_prefix = 'git-experimental'

390

301

experimental = True

391

roundtripping = True

392

393

BZR_FILE_IDS_FILE = '.bzrfileids'

394

395

BZR_DUMMY_FILE = '.bzrdummy'

396

302

397

303

def _decode_commit_message(self, rev, message, encoding):

398

304

message = self._extract_hg_metadata(rev, message)

399

305

message = self._extract_git_svn_metadata(rev, message)

400

message, metadata = self._extract_bzr_metadata(rev, message)

401

return message.decode(encoding), metadata

306

return message.decode(encoding)

402

307

403

308

def _encode_commit_message(self, rev, message, encoding):

404

309

ret = message.encode(encoding)

406

311

ret += self._generate_git_svn_metadata(rev, encoding)

407

312

return ret

408

313

409

def import_commit(self, commit, lookup_parent_revid):

410

rev, roundtrip_revid, verifiers = super(BzrGitMappingExperimental, self).import_commit(commit, lookup_parent_revid)

314

def import_commit(self, commit):

315

rev = super(BzrGitMappingExperimental, self).import_commit(commit)

411

316

rev.properties['converted_revision'] = "git %s\n" % commit.id

412

return rev, roundtrip_revid, verifiers

317

return rev

413

318

414

319

415

320

class GitMappingRegistry(VcsMappingRegistry):

417

322

418

323

def revision_id_bzr_to_foreign(self, bzr_revid):

419

324

if bzr_revid == NULL_REVISION:

420

from dulwich.protocol import ZERO_SHA

421

return ZERO_SHA, None

325

return "0" * 20, None

422

326

if not bzr_revid.startswith("git-"):

423

327

raise errors.InvalidRevisionId(bzr_revid, None)

424

328

(mapping_version, git_sha) = bzr_revid.split(":", 1)

430

334

431

335

mapping_registry = GitMappingRegistry()

432

336

mapping_registry.register_lazy('git-v1', "bzrlib.plugins.git.mapping",

433

"BzrGitMappingv1")

434

mapping_registry.register_lazy('git-experimental',

435

"bzrlib.plugins.git.mapping", "BzrGitMappingExperimental")

337

"BzrGitMappingv1")

338

mapping_registry.register_lazy('git-experimental', "bzrlib.plugins.git.mapping",

339

"BzrGitMappingExperimental")

436

340

mapping_registry.set_default('git-v1')

437

341

438

342

466

370

default_mapping = mapping_registry.get_default()()

467

371

468

372

373

def text_to_blob(texts, entry):

374

from dulwich.objects import Blob

375

text = texts.get_record_stream([(entry.file_id, entry.revision)], 'unordered', True).next().get_bytes_as('fulltext')

376

blob = Blob()

377

blob._text = text

378

return blob

379

380

469

381

def symlink_to_blob(entry):

470

382

from dulwich.objects import Blob

471

383

blob = Blob()

472

symlink_target = entry.symlink_target

473

if type(symlink_target) == unicode:

474

symlink_target = symlink_target.encode('utf-8')

475

blob.data = symlink_target

384

blob._text = entry.symlink_target

476

385

return blob

477

386

478

387

527

436

return object_mode(entry.kind, entry.executable)

528

437

529

438

530

def directory_to_tree(entry, lookup_ie_sha1, unusual_modes, empty_file_name):

531

"""Create a Git Tree object from a Bazaar directory.

532

533

:param entry: Inventory entry

534

:param lookup_ie_sha1: Lookup the Git SHA1 for a inventory entry

535

:param unusual_modes: Dictionary with unusual file modes by file ids

536

:param empty_file_name: Name to use for dummy files in empty directories,

537

None to ignore empty directories.

538

"""

539

from dulwich.objects import Blob, Tree

439

def directory_to_tree(entry, lookup_ie_sha1, unusual_modes):

440

from dulwich.objects import Tree

540

441

tree = Tree()

541

for name, value in entry.children.iteritems():

442

for name in sorted(entry.children.keys()):

542

443

ie = entry.children[name]

543

444

try:

544

445

mode = unusual_modes[ie.file_id]

545

446

except KeyError:

546

447

mode = entry_mode(ie)

547

hexsha = lookup_ie_sha1(ie)

448

if ie.kind == 'directory':

449

subtree = directory_to_tree(ie, lookup_ie_sha1, unusual_modes)

450

if subtree is None:

451

hexsha = None

452

else:

453

hexsha = subtree.id

454

else:

455

hexsha = lookup_ie_sha1(ie)

548

456

if hexsha is not None:

549

457

tree.add(mode, name.encode("utf-8"), hexsha)

550

458

if entry.parent_id is not None and len(tree) == 0:

551

459

# Only the root can be an empty tree

552

if empty_file_name is not None:

553

tree.add(stat.S_IFREG | 0644, empty_file_name,

554

Blob().id)

555

else:

556

return None

460

return None

461

tree.serialize()

557

462

return tree

558

463

559

464

560

465

def extract_unusual_modes(rev):

561

466

try:

562

foreign_revid, mapping = mapping_registry.parse_revision_id(

563

rev.revision_id)

467

foreign_revid, mapping = mapping_registry.parse_revision_id(rev.revision_id)

564

468

except errors.InvalidRevisionId:

565

469

return {}

566

470

else:

567

471

return mapping.export_unusual_file_modes(rev)

568

472

569

473

474

def inventory_to_tree_and_blobs(inventory, texts, mapping, unusual_modes, cur=None):

475

"""Convert a Bazaar tree to a Git tree.

476

477

:return: Yields tuples with object sha1, object and path

478

"""

479

from dulwich.objects import Tree

480

import stat

481

stack = []

482

if cur is None:

483

cur = ""

484

tree = Tree()

485

486

# stack contains the set of trees that we haven't

487

# finished constructing

488

for path, entry in inventory.iter_entries():

489

while stack and not path.startswith(osutils.pathjoin(cur, "")):

490

# We've hit a file that's not a child of the previous path

491

tree.serialize()

492

sha = tree.id

493

yield sha, tree, cur.encode("utf-8")

494

mode = unusual_modes.get(cur.encode("utf-8"), stat.S_IFDIR)

495

t = (mode, urlutils.basename(cur).encode('UTF-8'), sha)

496

cur, tree = stack.pop()

497

tree.add(*t)

498

499

if entry.kind == "directory":

500

stack.append((cur, tree))

501

cur = path

502

tree = Tree()

503

else:

504

if entry.kind == "file":

505

blob = text_to_blob(texts, entry)

506

elif entry.kind == "symlink":

507

blob = symlink_to_blob(entry)

508

else:

509

raise AssertionError("Unknown kind %s" % entry.kind)

510

sha = blob.id

511

yield sha, blob, path.encode("utf-8")

512

name = urlutils.basename(path).encode("utf-8")

513

mode = unusual_modes.get(path.encode("utf-8"), entry_mode(entry))

514

tree.add(mode, name, sha)

515

516

while len(stack) > 1:

517

tree.serialize()

518

sha = tree.id

519

yield sha, tree, cur.encode("utf-8")

520

mode = unusual_modes.get(cur.encode('utf-8'), stat.S_IFDIR)

521

t = (mode, urlutils.basename(cur).encode('UTF-8'), sha)

522

cur, tree = stack.pop()

523

tree.add(*t)

524

525

tree.serialize()

526

yield tree.id, tree, cur.encode("utf-8")

527

528

570

529

def parse_git_svn_id(text):

571

530

(head, uuid) = text.rsplit(" ", 1)

572

531

(full_url, rev) = head.rsplit("@", 1)

573

532

return (full_url, int(rev), uuid)

574

575

576

class GitFileIdMap(object):

577

578

def __init__(self, file_ids, mapping):

579

self.file_ids = file_ids

580

self.paths = None

581

self.mapping = mapping

582

583

def lookup_file_id(self, path):

584

assert type(path) is str

585

try:

586

file_id = self.file_ids[path]

587

except KeyError:

588

file_id = self.mapping.generate_file_id(path)

589

assert type(file_id) is str

590

return file_id

591

592

def lookup_path(self, file_id):

593

if self.paths is None:

594

self.paths = {}

595

for k, v in self.file_ids.iteritems():

596

self.paths[v] = k

597

try:

598

path = self.paths[file_id]

599

except KeyError:

600

return self.mapping.parse_file_id(file_id)

601

else:

602

assert type(path) is str

603

return path