* Update/verify the **version** in the `VERSION` file

* Update/verify that the `doc/source/changes.rst` changelog file was updated

* Commit everything

* Run `git tag -s <version>` to tag the version in Git

* Run `make release`

* Close the milestone mentioned in the _changelog_ and create a new one. _Do not reuse milestones by renaming them_.

* set the upcoming version in the `VERSION` file, usually be

incrementing the patch level, and possibly by appending `-dev`. Probably you

want to `git push` once more.

3.0.4

Changelog

3.0.4 - Bugfixes

see the following for details:

https://github.com/gitpython-developers/gitpython/milestone/31?closed=1

3.0.3 - Bugfixes

def handle_process_output(process, stdout_handler, stderr_handler,

finalizer=None, decode_streams=True):

"""Registers for notifications to learn that process output is ready to read, and dispatches lines to

url = os.path.expandvars(url)

if url.startswith('~'):

url = os.path.expanduser(url)

url = url.replace("\\\\", "\\").replace("\\", "/")

return url

proc.stderr.close()

# did the process finish already so we have a return code ?

try:

if proc.poll() is not None:

return

except OSError as ex:

log.info("Ignored error after process had died: %r", ex)

# can be that nothing really exists anymore ...

if os is None or getattr(os, 'kill', None) is None:

# R = Renamed

# M = Modified

# T = Changed in the type

change_type = ("A", "C", "D", "R", "M", "T")

def iter_change_type(self, change_type):

"""

yield diff

elif change_type == "D" and diff.deleted_file:

yield diff

elif change_type == "C" and diff.copied_file:

yield diff

elif change_type == "R" and diff.renamed:

yield diff

elif change_type == "M" and diff.a_blob and diff.b_blob and diff.a_blob != diff.b_blob:

# precompiled regex

re_header = re.compile(br"""

NULL_BIN_SHA = b"\0" * 20

__slots__ = ("a_blob", "b_blob", "a_mode", "b_mode", "a_rawpath", "b_rawpath",

"new_file", "deleted_file", "copied_file", "raw_rename_from",

"raw_rename_to", "diff", "change_type", "score")

def __init__(self, repo, a_rawpath, b_rawpath, a_blob_id, b_blob_id, a_mode,

b_mode, new_file, deleted_file, copied_file, raw_rename_from,

raw_rename_to, diff, change_type, score):

self.a_mode = a_mode

if self.b_mode:

self.b_mode = mode_str_to_int(self.b_mode)

# Determine whether this diff references a submodule, if it does then

# we need to overwrite "repo" to the corresponding submodule's repo instead

if repo and a_rawpath:

for submodule in repo.submodules:

if submodule.path == a_rawpath.decode("utf-8"):

repo = submodule.module()

break

if a_blob_id is None or a_blob_id == self.NULL_HEX_SHA:

self.a_blob = None

else:

self.new_file = new_file

self.deleted_file = deleted_file

self.copied_file = copied_file

# be clear and use None instead of empty strings

assert raw_rename_from is None or isinstance(raw_rename_from, binary_type)

msg += '\nfile deleted in rhs'

if self.new_file:

msg += '\nfile added in rhs'

if self.copied_file:

msg += '\nfile %r copied from %r' % (self.b_path, self.a_path)

if self.rename_from:

msg += '\nfile renamed from %r' % self.rename_from

if self.rename_to:

a_path_fallback, b_path_fallback, \

old_mode, new_mode, \

rename_from, rename_to, \

new_file_mode, deleted_file_mode, copied_file_name, \

a_blob_id, b_blob_id, b_mode, \

a_path, b_path = _header.groups()

new_file, deleted_file, copied_file = \

bool(new_file_mode), bool(deleted_file_mode), bool(copied_file_name)

a_path = cls._pick_best_path(a_path, rename_from, a_path_fallback)

b_path = cls._pick_best_path(b_path, rename_to, b_path_fallback)

b_blob_id and b_blob_id.decode(defenc),

a_mode and a_mode.decode(defenc),

b_mode and b_mode.decode(defenc),

new_file, deleted_file, copied_file,

rename_from,

rename_to,

None, None, None))

b_path = path.encode(defenc)

deleted_file = False

new_file = False

copied_file = False

rename_from = None

rename_to = None

elif change_type == 'A':

a_blob_id = None

new_file = True

elif change_type == 'C':

copied_file = True

a_path, b_path = path.split('\t', 1)

a_path = a_path.encode(defenc)

b_path = b_path.encode(defenc)

elif change_type == 'R':

a_path, b_path = path.split('\t', 1)

a_path = a_path.encode(defenc)

# END add/remove handling

diff = Diff(repo, a_path, b_path, a_blob_id, b_blob_id, old_mode, new_mode,

new_file, deleted_file, copied_file, rename_from, rename_to,

'', change_type, score)

index.append(diff)

handle_process_output(proc, handle_diff_line, None, finalize_process, decode_streams=False)

self._offset = timedelta(seconds=-secs_west_of_utc)

self._name = name or 'fixed'

def __reduce__(self):

return tzoffset, (-self._offset.total_seconds(), self._name)

def utcoffset(self, dt):

return self._offset

diff --git a/test1.txt b/test2.txt

similarity index 100%

copy from test1.txt

copy to test2.txt

:100644 100644 cfe9deac6e10683917e80f877566b58644aa21df cfe9deac6e10683917e80f877566b58644aa21df C100 test1.txt test2.txt

import ddt

import shutil

import tempfile

from git import (

Repo,

GitCommandError,

Diff,

DiffIndex,

NULL_TREE,

Submodule,

)

from git.cmd import Git

from git.test.lib import (

fixture,

assert_equal,

assert_true,

)

from git.test.lib import with_rw_directory

class TestDiff(TestBase):

def setUp(self):

self.repo_dir = tempfile.mkdtemp()

self.submodule_dir = tempfile.mkdtemp()

def tearDown(self):

import gc

gc.collect()

shutil.rmtree(self.repo_dir)

shutil.rmtree(self.submodule_dir)

def _assert_diff_format(self, diffs):

# verify that the format of the diff is sane

with open(fp, 'w') as fs:

fs.write("Hola Mundo")

r.git.add(Git.polish_url(fp))

self.assertEqual(len(r.index.diff("HEAD", create_patch=True)), 1,

"create_patch should generate patch of diff to HEAD")

r.git.commit(message="change on master")

self.assertEqual(len(r.index.diff("HEAD", create_patch=True)), 0,

"create_patch should generate no patch, already on HEAD")

r.git.checkout('HEAD~1', b='topic')

with open(fp, 'w') as fs:

fs.write("Hallo Welt")

r.git.commit(all=True, message="change on topic branch")

# there must be a merge-conflict

with self.assertRaises(GitCommandError):

r.git.cherry_pick('master')

# Now do the actual testing - this should just work

self.assertEqual(len(r.index.diff(None)), 2)

self.assertEqual(diff.score, 100)

self.assertEqual(len(list(diffs.iter_change_type('R'))), 1)

def test_diff_with_copied_file(self):

output = StringProcessAdapter(fixture('diff_copied_mode'))

diffs = Diff._index_from_patch_format(self.rorepo, output)

self._assert_diff_format(diffs)

assert_equal(1, len(diffs))

diff = diffs[0]

assert_true(diff.copied_file)

assert_true(diff.a_path, u'test1.txt')

assert_true(diff.b_path, u'test2.txt')

assert isinstance(str(diff), str)

output = StringProcessAdapter(fixture('diff_copied_mode_raw'))

diffs = Diff._index_from_raw_format(self.rorepo, output)

self.assertEqual(len(diffs), 1)

diff = diffs[0]

self.assertEqual(diff.change_type, 'C')

self.assertEqual(diff.score, 100)

self.assertEqual(diff.a_path, u'test1.txt')

self.assertEqual(diff.b_path, u'test2.txt')

self.assertEqual(len(list(diffs.iter_change_type('C'))), 1)

def test_diff_with_change_in_type(self):

output = StringProcessAdapter(fixture('diff_change_in_type'))

diffs = Diff._index_from_patch_format(self.rorepo, output)

self.assertIsNone(diff_index[0].a_path, repr(diff_index[0].a_path))

self.assertEqual(diff_index[0].b_path, u'file with spaces', repr(diff_index[0].b_path))

def test_diff_submodule(self):

"""Test that diff is able to correctly diff commits that cover submodule changes"""

# Init a temp git repo that will be referenced as a submodule

sub = Repo.init(self.submodule_dir)

with open(self.submodule_dir + "/subfile", "w") as sub_subfile:

sub_subfile.write("")

sub.index.add(["subfile"])

sub.index.commit("first commit")

# Init a temp git repo that will incorporate the submodule

repo = Repo.init(self.repo_dir)

with open(self.repo_dir + "/test", "w") as foo_test:

foo_test.write("")

repo.index.add(['test'])

Submodule.add(repo, "subtest", "sub", url="file://" + self.submodule_dir)

repo.index.commit("first commit")

repo.create_tag('1')

# Add a commit to the submodule

submodule = repo.submodule('subtest')

with open(self.repo_dir + "/sub/subfile", "w") as foo_sub_subfile:

foo_sub_subfile.write("blub")

submodule.module().index.add(["subfile"])

submodule.module().index.commit("changed subfile")

submodule.binsha = submodule.module().head.commit.binsha

# Commit submodule updates in parent repo

repo.index.add([submodule])

repo.index.commit("submodule changed")

repo.create_tag('2')

diff = repo.commit('1').diff(repo.commit('2'))[0]

# If diff is unable to find the commit hashes (looks in wrong repo) the *_blob.size

# property will be a string containing exception text, an int indicates success

self.assertIsInstance(diff.a_blob.size, int)

self.assertIsInstance(diff.b_blob.size, int)

def test_diff_interface(self):

# test a few variations of the main diff routine

assertion_map = {}