iframe-proxy | Sunbelt Computer Software

History

176 lines (134 loc) · 4.86 KB

Raw

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

"""Module with additional types used by the index"""

from binascii import b2a_hex

from .util import (

pack,

unpack

)

from git.objects import Blob

__all__ = ('BlobFilter', 'BaseIndexEntry', 'IndexEntry')

#{ Invariants

CE_NAMEMASK = 0x0fff

CE_STAGEMASK = 0x3000

CE_EXTENDED = 0x4000

CE_VALID = 0x8000

CE_STAGESHIFT = 12

#} END invariants

class BlobFilter(object):

"""

Predicate to be used by iter_blobs allowing to filter only return blobs which

match the given list of directories or files.

The given paths are given relative to the repository.

"""

__slots__ = 'paths'

def __init__(self, paths):

"""

:param paths:

tuple or list of paths which are either pointing to directories or

to files relative to the current repository

"""

self.paths = paths

def __call__(self, stage_blob):

path = stage_blob[1].path

for p in self.paths:

if path.startswith(p):

return True

# END for each path in filter paths

return False

class BaseIndexEntry(tuple):

"""Small Brother of an index entry which can be created to describe changes

done to the index in which case plenty of additional information is not required.

As the first 4 data members match exactly to the IndexEntry type, methods

expecting a BaseIndexEntry can also handle full IndexEntries even if they

use numeric indices for performance reasons. """

def __str__(self):

return "%o %s %i\t%s" % (self.mode, self.hexsha, self.stage, self.path)

def __repr__(self):

return "(%o, %s, %i, %s)" % (self.mode, self.hexsha, self.stage, self.path)

@property

def mode(self):

""" File Mode, compatible to stat module constants """

return self[0]

@property

def binsha(self):

"""binary sha of the blob """

return self[1]

@property

def hexsha(self):

"""hex version of our sha"""

return b2a_hex(self[1]).decode('ascii')

@property

def stage(self):

"""Stage of the entry, either:

* 0 = default stage

* 1 = stage before a merge or common ancestor entry in case of a 3 way merge

* 2 = stage of entries from the 'left' side of the merge

* 3 = stage of entries from the right side of the merge

:note: For more information, see http://www.kernel.org/pub/software/scm/git/docs/git-read-tree.html

"""

return (self[2] & CE_STAGEMASK) >> CE_STAGESHIFT

@property

def path(self):

""":return: our path relative to the repository working tree root"""

return self[3]

@property

def flags(self):

""":return: flags stored with this entry"""

return self[2]

@classmethod

def from_blob(cls, blob, stage=0):

""":return: Fully equipped BaseIndexEntry at the given stage"""

return cls((blob.mode, blob.binsha, stage << CE_STAGESHIFT, blob.path))

def to_blob(self, repo):

""":return: Blob using the information of this index entry"""

return Blob(repo, self.binsha, self.mode, self.path)

class IndexEntry(BaseIndexEntry):

"""Allows convenient access to IndexEntry data without completely unpacking it.

Attributes usully accessed often are cached in the tuple whereas others are

unpacked on demand.

See the properties for a mapping between names and tuple indices. """

@property

def ctime(self):

"""

:return:

Tuple(int_time_seconds_since_epoch, int_nano_seconds) of the

file's creation time"""

return unpack(">LL", self[4])

@property

def mtime(self):

"""See ctime property, but returns modification time """

return unpack(">LL", self[5])

@property

def dev(self):

""" Device ID """

return self[6]

@property

def inode(self):

""" Inode ID """

return self[7]

@property

def uid(self):

""" User ID """

return self[8]

@property

def gid(self):

""" Group ID """

return self[9]

@property

def size(self):

""":return: Uncompressed size of the blob """

return self[10]

@classmethod

def from_base(cls, base):

"""

:return:

Minimal entry as created from the given BaseIndexEntry instance.

Missing values will be set to null-like values

:param base: Instance of type BaseIndexEntry"""

time = pack(">LL", 0, 0)

return IndexEntry((base.mode, base.binsha, base.flags, base.path, time, time, 0, 0, 0, 0, 0))

@classmethod

def from_blob(cls, blob, stage=0):

""":return: Minimal entry resembling the given blob object"""

time = pack(">LL", 0, 0)

return IndexEntry((blob.mode, blob.binsha, stage << CE_STAGESHIFT, blob.path,

time, time, 0, 0, 0, 0, blob.size))

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Uh oh!

FilesExpand file tree

typ.py

Latest commit

History

typ.py

File metadata and controls