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

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

* 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

3.0.4

3.0.4 - Bugfixes

see the following for details:

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

"""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)

try:

if proc.poll() is not None:

return

except OSError as ex:

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

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

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

yield diff

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

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

b_mode, new_file, deleted_file, copied_file, raw_rename_from,

# 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

self.copied_file = copied_file

if self.copied_file:

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

new_file_mode, deleted_file_mode, copied_file_name, \

new_file, deleted_file, copied_file = \

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

new_file, deleted_file, copied_file,

copied_file = False

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)

new_file, deleted_file, copied_file, rename_from, rename_to,

'', change_type, score)

def __reduce__(self):

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

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 shutil

import tempfile

Submodule,

def setUp(self):

self.repo_dir = tempfile.mkdtemp()

self.submodule_dir = tempfile.mkdtemp()

shutil.rmtree(self.repo_dir)

shutil.rmtree(self.submodule_dir)

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")

with self.assertRaises(GitCommandError):

r.git.cherry_pick('master')

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_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)