GitPython/git/repo/fun.py at master · githubdelegate/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

"""Package with general repository related functions"""

import os

from string import digits

from gitdb.exc import (

BadObject,

BadName

)

from git.refs import SymbolicReference

from git.objects import Object

from gitdb.util import (

join,

isdir,

isfile,

dirname,

hex_to_bin,

bin_to_hex

)

from git.compat import xrange

__all__ = ('rev_parse', 'is_git_dir', 'touch', 'find_git_dir', 'name_to_object', 'short_to_long', 'deref_tag',

'to_commit')

def touch(filename):

fp = open(filename, "ab")

fp.close()

return filename

def is_git_dir(d):

""" This is taken from the git setup.c:is_git_directory

function."""

if isdir(d) and \

isdir(join(d, 'objects')) and \

isdir(join(d, 'refs')):

headref = join(d, 'HEAD')

return isfile(headref) or \

(os.path.islink(headref) and

os.readlink(headref).startswith('refs'))

return False

def find_git_dir(d):

if is_git_dir(d):

return d

try:

with open(d) as fp:

content = fp.read().rstrip()

except (IOError, OSError):

# it's probably not a file

pass

else:

if content.startswith('gitdir: '):

path = content[8:]

if not os.path.isabs(path):

path = join(dirname(d), path)

return find_git_dir(path)

# end handle exception

return None

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 or BadName

"""

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 BadName(name)

# END assert hexsha was found

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

def deref_tag(tag):

"""Recursively dereerence 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 as string, please see

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

for details

: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, "Requre 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 BadName("Invalid revision spec '%s' - not enough parent commits to reach '%s%i'" % (rev, token, num))

# 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

GitPython/git/repo/fun.py at master · githubdelegate/GitPython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

fun.py

Latest commit

History

Breadcrumbs

fun.py

File metadata and controls