/brz/remove-bazaar : revision 0.200.710

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

"""

144

152

145

153

def export_unusual_file_modes(self, rev):

146

154

try:

147

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

155

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

148

156

except KeyError:

149

157

return {}

150

158

159

def _generate_git_svn_metadata(self, rev):

160

try:

161

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

162

except KeyError:

163

return ""

164

165

def _generate_hg_message_tail(self, rev):

166

extra = {}

167

renames = []

168

branch = 'default'

169

for name in rev.properties:

170

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

171

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

172

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

173

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

174

elif name == 'hg:renames':

175

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

176

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

177

ret = format_hg_metadata(renames, branch, extra)

178

assert isinstance(ret, str)

179

return ret

180

181

def _extract_git_svn_metadata(self, rev, message):

182

lines = message.split("\n")

183

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

184

return message

185

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

186

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

187

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

188

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

189

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

190

assert isinstance(ret, str)

191

return ret

192

193

def _extract_hg_metadata(self, rev, message):

194

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

195

if branch is not None:

196

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

197

for name, value in extra.iteritems():

198

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

199

if renames:

200

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

201

return message

202

203

def _decode_commit_message(self, rev, message):

204

return message.decode("utf-8", "replace")

205

206

def _encode_commit_message(self, rev, message):

207

return message.encode("utf-8")

208

209

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

210

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

211

212

:param tree_sha: Tree sha for the commit

213

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

214

:return dulwich.objects.Commit represent the revision:

215

"""

216

from dulwich.objects import Commit

217

commit = Commit()

218

commit.tree = tree_sha

219

for p in rev.parent_ids:

220

try:

221

git_p = parent_lookup(p)

222

except KeyError:

223

git_p = None

224

if git_p is not None:

225

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

226

commit.parents.append(git_p)

227

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

228

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

229

commit.commit_time = long(rev.timestamp)

230

if 'author-timestamp' in rev.properties:

231

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

232

else:

233

commit.author_time = commit.commit_time

234

commit.commit_timezone = rev.timezone

235

if 'author-timezone' in rev.properties:

236

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

237

else:

238

commit.author_timezone = commit.commit_timezone

239

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

240

return commit

241

151

242

def import_commit(self, commit):

152

243

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

153

244

157

248

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

158

249

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

159

250

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

251

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

162

252

if commit.committer != commit.author:

163

253

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

168

258

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

169

259

rev.timestamp = commit.commit_time

170

260

rev.timezone = commit.commit_timezone

261

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

171

262

return rev

172

263

173

264

183

274

revid_prefix = 'git-experimental'

184

275

experimental = True

185

276

277

def _decode_commit_message(self, rev, message):

278

message = self._extract_hg_metadata(rev, message)

279

message = self._extract_git_svn_metadata(rev, message)

280

return message.decode("utf-8", "replace")

281

282

def _encode_commit_message(self, rev, message):

283

ret = message.encode("utf-8")

284

ret += self._generate_hg_message_tail(rev)

285

ret += self._generate_git_svn_metadata(rev)

286

return ret

287

288

def import_commit(self, commit):

289

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

290

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

291

return rev

292

186

293

187

294

class GitMappingRegistry(VcsMappingRegistry):

188

295

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

189

296

190

297

def revision_id_bzr_to_foreign(self, bzr_revid):

298

if bzr_revid == NULL_REVISION:

299

return "0" * 20, None

191

300

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

192

301

raise errors.InvalidRevisionId(bzr_revid, None)

193

302

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

202

311

"BzrGitMappingv1")

203

312

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

204

313

"BzrGitMappingExperimental")

314

mapping_registry.set_default('git-v1')

205

315

206

316

207

317

class ForeignGit(ForeignVcs):

208

318

"""The Git Stupid Content Tracker"""

209

319

320

@property

321

def branch_format(self):

322

from bzrlib.plugins.git.branch import GitBranchFormat

323

return GitBranchFormat()

324

325

@property

326

def repository_format(self):

327

from bzrlib.plugins.git.repository import GitRepositoryFormat

328

return GitRepositoryFormat()

329

210

330

def __init__(self):

211

331

super(ForeignGit, self).__init__(mapping_registry)

332

self.abbreviation = "git"

333

334

@classmethod

335

def serialize_foreign_revid(self, foreign_revid):

336

return foreign_revid

212

337

213

338

@classmethod

214

339

def show_foreign_revid(cls, foreign_revid):

216

341

217

342

218

343

foreign_git = ForeignGit()

219

default_mapping = BzrGitMappingv1()

344

default_mapping = mapping_registry.get_default()()

220

345

221

346

222

347

def text_to_blob(texts, entry):

260

385

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

261

386

262

387

263

def entry_mode(entry):

264

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

265

if entry.kind == 'directory':

388

def object_mode(kind, executable):

389

if kind == 'directory':

266

390

return stat.S_IFDIR

267

elif entry.kind == 'symlink':

268

return stat.S_IFLNK

269

elif entry.kind == 'file':

391

elif kind == 'symlink':

392

mode = stat.S_IFLNK

393

if executable:

394

mode |= 0111

395

return mode

396

elif kind == 'file':

270

397

mode = stat.S_IFREG | 0644

271

if entry.executable:

398

if executable:

272

399

mode |= 0111

273

400

return mode

401

elif kind == 'tree-reference':

402

from dulwich.objects import S_IFGITLINK

403

return S_IFGITLINK

274

404

else:

275

405

raise AssertionError

276

406

277

407

408

def entry_mode(entry):

409

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

410

return object_mode(entry.kind, entry.executable)

411

412

278

413

def directory_to_tree(entry, lookup_ie_sha1, unusual_modes):

279

414

from dulwich.objects import Tree

280

415

tree = Tree()

284

419

mode = unusual_modes[ie.file_id]

285

420

except KeyError:

286

421

mode = entry_mode(ie)

287

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

422

hexsha = lookup_ie_sha1(ie)

423

if hexsha is not None:

424

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

425

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

426

# Only the root can be an empty tree

427

return None

288

428

tree.serialize()

289

429

return tree

290

430

310

450

cur = ""

311

451

tree = Tree()

312

452

313

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

453

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

314

454

# finished constructing

315

455

for path, entry in inventory.iter_entries():

316

456

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

353

493

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

354

494

355

495

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

496

def parse_git_svn_id(text):

497

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

498

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

499

return (full_url, int(rev), uuid)