/brz/remove-bazaar : revision 0.200.813

18

19

"""Converters, etc for going between Bazaar and Git ids."""

20

21

import base64

21

22

import stat

22

23

24

from bzrlib import (

35

36

ROOT_ID,

36

37

)

37

38

from bzrlib.foreign import (

38

ForeignVcs,

39

VcsMappingRegistry,

39

ForeignVcs,

40

VcsMappingRegistry,

40

41

ForeignRevision,

41

42

)

43

from bzrlib.revision import (

44

NULL_REVISION,

45

)

46

from bzrlib.plugins.git.hg import (

47

format_hg_metadata,

48

extract_hg_metadata,

49

)

42

50

43

51

DEFAULT_FILE_MODE = stat.S_IFREG | 0644

44

52

83

91

84

92

def squash_revision(target_repo, rev):

85

93

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

86

94

87

95

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

88

96

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

89

97

"""

111

119

super(BzrGitMapping, self).__init__(foreign_git)

112

120

113

121

def __eq__(self, other):

114

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

122

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

123

self.revid_prefix == other.revid_prefix)

115

124

116

125

@classmethod

117

126

def revision_id_foreign_to_bzr(cls, git_rev_id):

118

127

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

128

if git_rev_id == "0" * 40:

129

return NULL_REVISION

119

130

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

120

131

121

132

@classmethod

139

150

140

151

def import_unusual_file_modes(self, rev, unusual_file_modes):

141

152

if unusual_file_modes:

142

ret = [(name, unusual_file_modes[name]) for name in sorted(unusual_file_modes.keys())]

153

ret = [(name, unusual_file_modes[name])

154

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

143

155

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

144

156

145

157

def export_unusual_file_modes(self, rev):

146

158

try:

147

return dict([(self.generate_file_id(path), mode) for (path, mode) in bencode.bdecode(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"))])

148

160

except KeyError:

149

161

return {}

150

162

163

def _generate_git_svn_metadata(self, rev, encoding):

164

try:

165

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

166

except KeyError:

167

return ""

168

169

def _generate_hg_message_tail(self, rev):

170

extra = {}

171

renames = []

172

branch = 'default'

173

for name in rev.properties:

174

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

175

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

176

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

177

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

178

elif name == 'hg:renames':

179

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

180

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

181

ret = format_hg_metadata(renames, branch, extra)

182

assert isinstance(ret, str)

183

return ret

184

185

def _extract_git_svn_metadata(self, rev, message):

186

lines = message.split("\n")

187

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

188

return message

189

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

190

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

191

(url, rev, uuid) = parse_git_svn_id(git_svn_id)

192

# FIXME: Convert this to converted-from property somehow..

193

ret = "\n".join(lines[:-2])

194

assert isinstance(ret, str)

195

return ret

196

197

def _extract_hg_metadata(self, rev, message):

198

(message, renames, branch, extra) = extract_hg_metadata(message)

199

if branch is not None:

200

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

201

for name, value in extra.iteritems():

202

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

203

if renames:

204

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

205

return message

206

207

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

208

return message.decode(encoding)

209

210

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

211

return message.encode(encoding)

212

213

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

214

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

215

216

:param tree_sha: Tree sha for the commit

217

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

218

:return dulwich.objects.Commit represent the revision:

219

"""

220

from dulwich.objects import Commit

221

commit = Commit()

222

commit.tree = tree_sha

223

for p in rev.parent_ids:

224

try:

225

git_p = parent_lookup(p)

226

except KeyError:

227

git_p = None

228

if git_p is not None:

229

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

230

commit.parents.append(git_p)

231

try:

232

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

233

except KeyError:

234

encoding = rev.properties.get('git-implicit-encoding', 'utf-8')

235

commit.encoding = rev.properties.get('git-explicit-encoding')

236

commit.committer = fix_person_identifier(rev.committer.encode(

237

encoding))

238

commit.author = fix_person_identifier(

239

rev.get_apparent_authors()[0].encode(encoding))

240

commit.commit_time = long(rev.timestamp)

241

if 'author-timestamp' in rev.properties:

242

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

243

else:

244

commit.author_time = commit.commit_time

245

commit.commit_timezone = rev.timezone

246

if 'author-timezone' in rev.properties:

247

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

248

else:

249

commit.author_timezone = commit.commit_timezone

250

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

251

encoding)

252

return commit

253

151

254

def import_commit(self, commit):

152

255

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

153

256

157

260

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

158

261

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

159

262

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

160

rev.message = commit.message.decode("utf-8", "replace")

161

rev.committer = str(commit.committer).decode("utf-8", "replace")

162

if commit.committer != commit.author:

163

rev.properties['author'] = str(commit.author).decode("utf-8", "replace")

164

263

def decode_using_encoding(rev, commit, encoding):

264

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

265

if commit.committer != commit.author:

266

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

267

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

268

encoding)

269

if commit.encoding is not None:

270

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

271

decode_using_encoding(rev, commit, commit.encoding)

272

else:

273

for encoding in ('utf-8', 'latin1'):

274

try:

275

decode_using_encoding(rev, commit, encoding)

276

except UnicodeDecodeError:

277

pass

278

else:

279

if encoding != 'utf-8':

280

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

281

break

165

282

if commit.commit_time != commit.author_time:

166

283

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

167

284

if commit.commit_timezone != commit.author_timezone:

183

300

revid_prefix = 'git-experimental'

184

301

experimental = True

185

302

303

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

304

message = self._extract_hg_metadata(rev, message)

305

message = self._extract_git_svn_metadata(rev, message)

306

return message.decode(encoding)

307

308

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

309

ret = message.encode(encoding)

310

ret += self._generate_hg_message_tail(rev)

311

ret += self._generate_git_svn_metadata(rev, encoding)

312

return ret

313

314

def import_commit(self, commit):

315

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

316

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

317

return rev

318

186

319

187

320

class GitMappingRegistry(VcsMappingRegistry):

188

321

"""Registry with available git mappings."""

189

322

190

323

def revision_id_bzr_to_foreign(self, bzr_revid):

324

if bzr_revid == NULL_REVISION:

325

return "0" * 20, None

191

326

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

192

327

raise errors.InvalidRevisionId(bzr_revid, None)

193

328

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

202

337

"BzrGitMappingv1")

203

338

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

204

339

"BzrGitMappingExperimental")

340

mapping_registry.set_default('git-v1')

205

341

206

342

207

343

class ForeignGit(ForeignVcs):

208

344

"""The Git Stupid Content Tracker"""

209

345

346

@property

347

def branch_format(self):

348

from bzrlib.plugins.git.branch import GitBranchFormat

349

return GitBranchFormat()

350

351

@property

352

def repository_format(self):

353

from bzrlib.plugins.git.repository import GitRepositoryFormat

354

return GitRepositoryFormat()

355

210

356

def __init__(self):

211

357

super(ForeignGit, self).__init__(mapping_registry)

358

self.abbreviation = "git"

359

360

@classmethod

361

def serialize_foreign_revid(self, foreign_revid):

362

return foreign_revid

212

363

213

364

@classmethod

214

365

def show_foreign_revid(cls, foreign_revid):

216

367

217

368

218

369

foreign_git = ForeignGit()

219

default_mapping = BzrGitMappingv1()

220

221

222

def text_to_blob(texts, entry):

223

from dulwich.objects import Blob

224

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

225

blob = Blob()

226

blob._text = text

227

return blob

370

default_mapping = mapping_registry.get_default()()

228

371

229

372

230

373

def symlink_to_blob(entry):

231

374

from dulwich.objects import Blob

232

375

blob = Blob()

233

blob._text = entry.symlink_target

376

symlink_target = entry.symlink_target

377

if type(symlink_target) == unicode:

378

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

379

blob.data = symlink_target

234

380

return blob

235

381

236

382

260

406

"Unknown kind, perms=%r." % (mode,))

261

407

262

408

263

def entry_mode(entry):

264

"""Determine the git file mode for an inventory entry."""

265

if entry.kind == 'directory':

409

def object_mode(kind, executable):

410

if kind == 'directory':

266

411

return stat.S_IFDIR

267

elif entry.kind == 'symlink':

268

return stat.S_IFLNK

269

elif entry.kind == 'file':

412

elif kind == 'symlink':

413

mode = stat.S_IFLNK

414

if executable:

415

mode |= 0111

416

return mode

417

elif kind == 'file':

270

418

mode = stat.S_IFREG | 0644

271

if entry.executable:

419

if executable:

272

420

mode |= 0111

273

421

return mode

422

elif kind == 'tree-reference':

423

from dulwich.objects import S_IFGITLINK

424

return S_IFGITLINK

274

425

else:

275

426

raise AssertionError

276

427

277

428

429

def entry_mode(entry):

430

"""Determine the git file mode for an inventory entry."""

431

return object_mode(entry.kind, entry.executable)

432

433

278

434

def directory_to_tree(entry, lookup_ie_sha1, unusual_modes):

279

435

from dulwich.objects import Tree

280

436

tree = Tree()

281

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

437

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

282

438

ie = entry.children[name]

283

439

try:

284

440

mode = unusual_modes[ie.file_id]

285

441

except KeyError:

286

442

mode = entry_mode(ie)

287

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

288

tree.serialize()

443

hexsha = lookup_ie_sha1(ie)

444

if hexsha is not None:

445

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

446

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

447

# Only the root can be an empty tree

448

return None

289

449

return tree

290

450

291

451

310

470

cur = ""

311

471

tree = Tree()

312

472

313

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

473

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

314

474

# finished constructing

315

475

for path, entry in inventory.iter_entries():

316

476

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

317

477

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

318

tree.serialize()

319

478

sha = tree.id

320

479

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

321

480

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

329

488

tree = Tree()

330

489

else:

331

490

if entry.kind == "file":

332

blob = text_to_blob(texts, entry)

491

from dulwich.objects import Blob

492

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

493

blob = Blob()

494

blob.data = text

333

495

elif entry.kind == "symlink":

334

496

blob = symlink_to_blob(entry)

335

497

else:

341

503

tree.add(mode, name, sha)

342

504

343

505

while len(stack) > 1:

344

tree.serialize()

345

506

sha = tree.id

346

507

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

347

508

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

349

510

cur, tree = stack.pop()

350

511

tree.add(*t)

351

512

352

tree.serialize()

353

513

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

354

514

355

515

356

def revision_to_commit(rev, tree_sha, parent_lookup):

357

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

358

359

:param tree_sha: Tree sha for the commit

360

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

361

:return dulwich.objects.Commit represent the revision:

362

"""

363

from dulwich.objects import Commit

364

commit = Commit()

365

commit.tree = tree_sha

366

for p in rev.parent_ids:

367

git_p = parent_lookup(p)

368

if git_p is not None:

369

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

370

commit.parents.append(git_p)

371

commit.message = rev.message.encode("utf-8")

372

commit.committer = fix_person_identifier(rev.committer.encode("utf-8"))

373

commit.author = fix_person_identifier(rev.get_apparent_authors()[0].encode("utf-8"))

374

commit.commit_time = long(rev.timestamp)

375

if 'author-timestamp' in rev.properties:

376

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

377

else:

378

commit.author_time = commit.commit_time

379

commit.commit_timezone = rev.timezone

380

if 'author-timezone' in rev.properties:

381

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

382

else:

383

commit.author_timezone = commit.commit_timezone

384

return commit

516

def parse_git_svn_id(text):

517

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

518

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

519

return (full_url, int(rev), uuid)