GitPython/git/db/py/resolve.py at experiment-2012 · felixdevelop/GitPython · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

"""Module with an implementation for refspec parsing. It is the pure-python

version assuming compatible interface for reference and object types"""

from git.db.interface import ReferencesMixin

from git.exc import BadObject

from git.refs import (

SymbolicReference,

Reference,

HEAD,

Head,

TagReference

)

from git.refs.head import HEAD

from git.refs.headref import Head

from git.refs.tag import TagReference

from git.objects.base import Object

from git.objects.commit import Commit

from git.util import (

join,

isdir,

isfile,

hex_to_bin,

bin_to_hex,

is_git_dir

)

from string import digits

import os

import re

__all__ = ["PureReferencesMixin"]

#{ Utilities

def short_to_long(odb, hexsha):

""":return: long hexadecimal sha1 from the given less-than-40 byte hexsha

or None if no candidate could be found.

:param hexsha: hexsha with less than 40 byte"""

try:

return bin_to_hex(odb.partial_to_complete_sha_hex(hexsha))

except BadObject:

return None

# END exception handling

def name_to_object(repo, name, return_ref=False):

"""

:return: object specified by the given name, hexshas ( short and long )

as well as references are supported

:param return_ref: if name specifies a reference, we will return the reference

instead of the object. Otherwise it will raise BadObject

"""

hexsha = None

# is it a hexsha ? Try the most common ones, which is 7 to 40

if repo.re_hexsha_shortened.match(name):

if len(name) != 40:

# find long sha for short sha

hexsha = short_to_long(repo.odb, name)

else:

hexsha = name

# END handle short shas

# END find sha if it matches

# if we couldn't find an object for what seemed to be a short hexsha

# try to find it as reference anyway, it could be named 'aaa' for instance

if hexsha is None:

for base in ('%s', 'refs/%s', 'refs/tags/%s', 'refs/heads/%s', 'refs/remotes/%s', 'refs/remotes/%s/HEAD'):

try:

hexsha = SymbolicReference.dereference_recursive(repo, base % name)

if return_ref:

return SymbolicReference(repo, base % name)

# END handle symbolic ref

break

except ValueError:

pass

# END for each base

# END handle hexsha

# didn't find any ref, this is an error

if return_ref:

raise BadObject("Couldn't find reference named %r" % name)

# END handle return ref

# tried everything ? fail

if hexsha is None:

raise BadObject(name)

# END assert hexsha was found

return Object.new_from_sha(repo, hex_to_bin(hexsha))

def deref_tag(tag):

"""Recursively dereference a tag and return the resulting object"""

while True:

try:

tag = tag.object

except AttributeError:

break

# END dereference tag

return tag

def to_commit(obj):

"""Convert the given object to a commit if possible and return it"""

if obj.type == 'tag':

obj = deref_tag(obj)

if obj.type != "commit":

raise ValueError("Cannot convert object %r to type commit" % obj)

# END verify type

return obj

def rev_parse(repo, rev):

"""

:return: Object at the given revision, either Commit, Tag, Tree or Blob

:param rev: git-rev-parse compatible revision specification, please see

http://www.kernel.org/pub/software/scm/git/docs/git-rev-parse.html

for details

:note: Currently there is no access to the rev-log, rev-specs may only contain

topological tokens such ~ and ^.

:raise BadObject: if the given revision could not be found

:raise ValueError: If rev couldn't be parsed

:raise IndexError: If invalid reflog index is specified"""

# colon search mode ?

if rev.startswith(':/'):

# colon search mode

raise NotImplementedError("commit by message search ( regex )")

# END handle search

obj = None

ref = None

output_type = "commit"

start = 0

parsed_to = 0

lr = len(rev)

while start < lr:

if rev[start] not in "^~:@":

start += 1

continue

# END handle start

token = rev[start]

if obj is None:

# token is a rev name

if start == 0:

ref = repo.head.ref

else:

if token == '@':

ref = name_to_object(repo, rev[:start], return_ref=True)

else:

obj = name_to_object(repo, rev[:start])

# END handle token

# END handle refname

if ref is not None:

obj = ref.commit

# END handle ref

# END initialize obj on first token

start += 1

# try to parse {type}

if start < lr and rev[start] == '{':

end = rev.find('}', start)

if end == -1:

raise ValueError("Missing closing brace to define type in %s" % rev)

output_type = rev[start + 1:end] # exclude brace

# handle type

if output_type == 'commit':

pass # default

elif output_type == 'tree':

try:

obj = to_commit(obj).tree

except (AttributeError, ValueError):

pass # error raised later

# END exception handling

elif output_type in ('', 'blob'):

if obj.type == 'tag':

obj = deref_tag(obj)

else:

# cannot do anything for non-tags

pass

# END handle tag

elif token == '@':

# try single int

assert ref is not None, "Require Reference to access reflog"

revlog_index = None

try:

# transform reversed index into the format of our revlog

revlog_index = -(int(output_type) + 1)

except ValueError:

# TODO: Try to parse the other date options, using parse_date

# maybe

raise NotImplementedError("Support for additional @{...} modes not implemented")

# END handle revlog index

try:

entry = ref.log_entry(revlog_index)

except IndexError:

raise IndexError("Invalid revlog index: %i" % revlog_index)

# END handle index out of bound

obj = Object.new_from_sha(repo, hex_to_bin(entry.newhexsha))

# make it pass the following checks

output_type = None

else:

raise ValueError("Invalid output type: %s ( in %s )" % (output_type, rev))

# END handle output type

# empty output types don't require any specific type, its just about dereferencing tags

if output_type and obj.type != output_type:

raise ValueError("Could not accomodate requested object type %r, got %s" % (output_type, obj.type))

# END verify ouput type

start = end + 1 # skip brace

parsed_to = start

continue

# END parse type

# try to parse a number

num = 0

if token != ":":

found_digit = False

while start < lr:

if rev[start] in digits:

num = num * 10 + int(rev[start])

start += 1

found_digit = True

else:

break

# END handle number

# END number parse loop

# no explicit number given, 1 is the default

# It could be 0 though

if not found_digit:

num = 1

# END set default num

# END number parsing only if non-blob mode

parsed_to = start

# handle hiererarchy walk

try:

if token == "~":

obj = to_commit(obj)

for item in xrange(num):

obj = obj.parents[0]

# END for each history item to walk

elif token == "^":

obj = to_commit(obj)

# must be n'th parent

if num:

obj = obj.parents[num - 1]

elif token == ":":

if obj.type != "tree":

obj = obj.tree

# END get tree type

obj = obj[rev[start:]]

parsed_to = lr

else:

raise ValueError("Invalid token: %r" % token)

# END end handle tag

except (IndexError, AttributeError):

raise BadObject("Invalid Revision in %s" % rev)

# END exception handling

# END parse loop

# still no obj ? Its probably a simple name

if obj is None:

obj = name_to_object(repo, rev)

parsed_to = lr

# END handle simple name

if obj is None:

raise ValueError("Revision specifier could not be parsed: %s" % rev)

if parsed_to != lr:

raise ValueError("Didn't consume complete rev spec %s, consumed part: %s" % (rev, rev[:parsed_to]))

return obj

#} END utilities

class PureReferencesMixin(ReferencesMixin):

"""Pure-Python refparse implementation"""

re_hexsha_only = re.compile('^[0-9A-Fa-f]{40}$')

re_hexsha_shortened = re.compile('^[0-9A-Fa-f]{4,40}$')

#{ Configuration

# Types to use when instatiating references

TagReferenceCls = TagReference

HeadCls = Head

ReferenceCls = Reference

HEADCls = HEAD

CommitCls = Commit

#} END configuration

def resolve(self, name):

return self.resolve_object(name).binsha

def resolve_object(self, name):

return rev_parse(self, name)

@property

def references(self):

return self.ReferenceCls.list_items(self)

@property

def heads(self):

return self.HeadCls.list_items(self)

@property

def tags(self):

return self.TagReferenceCls.list_items(self)

def tag(self, name):

return self.TagReferenceCls(self, self.TagReferenceCls.to_full_path(name))

def commit(self, rev=None):

if rev is None:

return self.head.commit

else:

return self.resolve_object(str(rev) + "^0")

# END handle revision

def iter_trees(self, *args, **kwargs):

return (c.tree for c in self.iter_commits(*args, **kwargs))

def tree(self, rev=None):

if rev is None:

return self.head.commit.tree

else:

return self.resolve_object(str(rev) + "^{tree}")

def iter_commits(self, rev=None, paths='', **kwargs):

if rev is None:

rev = self.head.commit

return self.CommitCls.iter_items(self, rev, paths, **kwargs)

@property

def head(self):

return self.HEADCls(self, 'HEAD')

def create_head(self, path, commit='HEAD', force=False, logmsg=None):

return self.HeadCls.create(self, path, commit, force, logmsg)

def delete_head(self, *heads, **kwargs):

return self.HeadCls.delete(self, *heads, **kwargs)

def create_tag(self, path, ref='HEAD', message=None, force=False, **kwargs):

return self.TagReferenceCls.create(self, path, ref, message, force, **kwargs)

def delete_tag(self, *tags):

return self.TagReferenceCls.delete(self, *tags)

GitPython/git/db/py/resolve.py at experiment-2012 · felixdevelop/GitPython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

resolve.py

Latest commit

History

Breadcrumbs

resolve.py

File metadata and controls