0.3.4 - python 3 support

* Internally, hexadecimal SHA1 are treated as ascii encoded strings. Binary SHA1 are treated as bytes.

* Id attribute of Commit objects is now `hexsha`, instead of `binsha`. The latter makes no sense in python 3 and I see no application of it anyway besides its artificial usage in test cases.

0.3.3

else:

raiseGitCommandError(command,status,stderr_value)

ifisinstance(stdout_value,bytes):# could also be output_stream

stdout_value=stdout_value.decode(defenc)

ifwith_extended_output:

return (status,stdout_value,stderr_value)

return (status,stdout_value,stderr_value.decode(defenc))

else:

self.write()

exceptIOError:

log.error("Exception during destruction of GitConfigParser",exc_info=True)

exceptReferenceError:

finally:

self._lock._release_lock()

ifnothasattr(fp,"seek"):

fp=open(self._file_or_files,"w")

fp=open(self._file_or_files,"wb")

else:

fp.seek(0)

""",re.VERBOSE|re.MULTILINE)

__slots__= ("a_blob","b_blob","a_mode","b_mode","new_file","deleted_file",

"rename_from","rename_to","diff")

TYPES= (dbtyp.str_blob_type,dbtyp.str_tree_type,dbtyp.str_commit_type,dbtyp.str_tag_type)

__slots__= ("repo","binsha","size")

def__str__(self):

returnbin_to_hex(self.binsha)

returnself.hexsha

def__repr__(self):

defhexsha(self):

returnbin_to_hex(self.binsha)

returnbin_to_hex(self.binsha).decode('ascii')

defdata_stream(self):

"author","authored_date","author_tz_offset",

"committer","committed_date","committer_tz_offset",

"message","parents","encoding","gpgsig")

def__init__(self,repo,binsha,tree=None,author=None,authored_date=None,author_tz_offset=None,

committer=None,committed_date=None,committer_tz_offset=None,

write(("encoding %s\n"%self.encoding).encode('ascii'))

ifself.gpgsig:

write("gpgsig")

write(b"gpgsig")

forsiglineinself.gpgsig.rstrip("\n").split("\n"):

write((" "+sigline+"\n").encode('ascii'))

fromgit.compatimport (

byte_ord,

force_bytes,

defenc,

xrange,

ifisinstance(name,text_type):

name=name.encode(defenc)

write(b''.join(mode_str,b' ',name,b'\0',binsha))

write(b''.join((mode_str,b' ',name,b'\0',binsha)))

deftree_entries_from_data(data):

lfd=LockedFD(fpath)

fd=lfd.open(write=True,stream=True)

fd.write(write_value)

fd.write(write_value.encode('ascii'))

lfd.commit()

read_gitfile,

touch,

)

fromgit.compatimporttext_type

fromgit.compatimport (

text_type,

)

def_get_description(self):

filename=join(self.git_dir,'description')

returnopen(filename).read().rstrip()

returnopen(filename,'rb').read().rstrip().decode(defenc)

def_set_description(self,descr):

filename=join(self.git_dir,'description')

open(filename,'w').write(descr+'\n')

open(filename,'wb').write((descr+'\n').encode(defenc))

description=property(_get_description,_set_description,

doc="the project's description")

ifos.path.exists(alternates_path):

try:

f=open(alternates_path)

alts=f.read()

f=open(alternates_path,'rb')

alts=f.read().decode(defenc)

finally:

f.close()

returnalts.strip().splitlines()

os.remove(alternates_path)

else:

try:

f=open(alternates_path,'w')

f.write("\n".join(alts))

f=open(alternates_path,'wb')

f.write("\n".join(alts).encode(defenc))

finally:

f.close()

stream.seek(0)

istream=rwrepo.odb.store(IStream(Commit.type,streamlen,stream))

assertistream.hexsha==cm.hexsha

assertistream.hexsha==cm.hexsha.encode('ascii')

nc=Commit(rwrepo,Commit.NULL_BIN_SHA,cm.tree,

cm.author,cm.authored_date,cm.author_tz_offset,

deftest_unicode_actor(self):

assertlen(name)==9

special=Actor._from_string(u"%s <something@this.com>"%name)

assertspecial.name==name

dfirst=start.traverse(branch_first=False)

bfirst=start.traverse(branch_first=True)

assertdfirst.next()==p0

assertdfirst.next()==p00

assertnext(dfirst)==p0

assertnext(dfirst)==p00

assertbfirst.next()==p0

assertbfirst.next()==p1

assertbfirst.next()==p00

assertbfirst.next()==p10

assertnext(bfirst)==p0

assertnext(bfirst)==p1

assertnext(bfirst)==p00

assertnext(bfirst)==p10

assertlist(bfirst)[-1]==first

assertlen(l[0])==2

assertstart.traverse(ignore_self=False).next()==start

assertnext(start.traverse(ignore_self=False))==start

assertlen(list(start.traverse(ignore_self=False,depth=0)))==1

assertstart.traverse(branch_first=1,prune=lambdai,d:i==p0).next()==p1

assertnext(start.traverse(branch_first=1,prune=lambdai,d:i==p0))==p1

assertstart.traverse(branch_first=1,predicate=lambdai,d:i==p1).next()==p1

assertnext(start.traverse(branch_first=1,predicate=lambdai,d:i==p1))==p1

self.failUnlessRaises(StopIteration,first.traverse().next)

self.failUnlessRaises(StopIteration,next,first.traverse())

first_parent=True,

bisect_all=True)

commits=Commit._iter_from_process_or_stream(self.rorepo,StringProcessAdapter(revs))

commits=Commit._iter_from_process_or_stream(self.rorepo,StringProcessAdapter(revs.encode('ascii')))

expected_ids= (

'7156cece3c49544abb6bf7a0c218eb36646fad6d',

'1f66cfbbce58b4b552b041707a12d437cc5f400a',

assertself.rorepo.tag('refs/tags/0.1.5').commit.count()==143

deftest_list(self):

assertisinstance(Commit.list_items(self.rorepo,'0.1.5',max_count=5)[

hex_to_bin('5117c9c8a4d3af19a9958677e45cda9269de1541')],Commit)

'5117c9c8a4d3af19a9958677e45cda9269de1541'],Commit)

deftest_str(self):

commit=Commit(self.rorepo,Commit.NULL_BIN_SHA)

c=self.rorepo.commit('0.1.5')

forskipin (0,1):

piter=c.iter_parents(skip=skip)

first_parent=piter.next()

first_parent=next(piter)

assertfirst_parent==c.parents[0]

deftest_base(self):

deftest_name_rev(self):

name_rev=self.rorepo.head.commit.name_rev

assertisinstance(name_rev,string_types)

assertisinstance(cmt.message,text_type)# it automatically decodes it as such

assertisinstance(cmt.author.name,text_type)# same here

cmt.message="üäêèß".decode("utf-8")

cmt.message=u"üäêèß"

assertlen(cmt.message)==5

cmt.author.name="äüß".decode("utf-8")

cmt.author.name=u"äüß"

assertlen(cmt.author.name)==3

cstream=BytesIO()

deftest_gpgsig(self):

cmt=self.rorepo.commit()

cmt._deserialize(open(fixture_path('commit_with_gpgsig')))

cmt._deserialize(open(fixture_path('commit_with_gpgsig'),'rb'))

cstream=BytesIO()

cmt._serialize(cstream)

assertre.search(r"^gpgsig <test\n dummy\n sig>$",cstream.getvalue(),re.MULTILINE)

assertre.search(r"^gpgsig <test\n dummy\n sig>$",cstream.getvalue().decode('ascii'),re.MULTILINE)

cstream.seek(0)

cmt.gpgsig=None

cmt.gpgsig=None

cstream=BytesIO()

cmt._serialize(cstream)

assertnotre.search(r"^gpgsig ",cstream.getvalue(),re.MULTILINE)

assertnotre.search(r"^gpgsig ",cstream.getvalue().decode('ascii'),re.MULTILINE)