pep8 linting (whitespaces)

W191 indentation contains tabs
E221 multiple spaces before operator
E222 multiple spaces after operator
E225 missing whitespace around operator
E271 multiple spaces after keyword
W292 no newline at end of file
W293 blank line contains whitespace
W391 blank line at end of file

1 files changed, 78 insertions, 79 deletions

diff --git a/git/test/test_refs.py b/git/test/test_refs.py
index cf08d7ec..5eb214ba 100644
--- a/git/test/test_refs.py
+++ b/git/test/test_refs.py
@@ -24,12 +24,12 @@ class TestRefs(TestBase):
                 assert isinstance(instance, ref_type)
             # END for each name 
         # END for each type
-        
+
         # invalid path
         self.failUnlessRaises(ValueError, TagReference, self.rorepo, "refs/invalid/tag")
         # works without path check
         TagReference(self.rorepo, "refs/invalid/tag", check_path=False)
-    
+
     def test_tag_base(self):
         tag_object_refs = list()
         for tag in self.rorepo.tags:
@@ -64,7 +64,7 @@ class TestRefs(TestBase):
         assert tagger_name == 'Michael Trier'
 
 
-        
+
     def test_tags(self):
         # tag refs can point to tag objects or to commits
         s = set()
@@ -80,7 +80,7 @@ class TestRefs(TestBase):
         # END for each ref
         assert len(s) == ref_count
         assert len(s|s) == ref_count
-        
+
     @with_rw_repo('HEAD', bare=False)
     def test_heads(self, rwrepo):
         for head in rwrepo.heads:
@@ -91,7 +91,7 @@ class TestRefs(TestBase):
             cur_object = head.object
             assert prev_object == cur_object        # represent the same git object
             assert prev_object is not cur_object    # but are different instances
-            
+
             writer = head.config_writer()
             tv = "testopt"
             writer.set_value(tv, 1)
@@ -99,7 +99,7 @@ class TestRefs(TestBase):
             del(writer)
             assert head.config_reader().get_value(tv) == 1
             head.config_writer().remove_option(tv)
-            
+
             # after the clone, we might still have a tracking branch setup
             head.set_tracking_branch(None)
             assert head.tracking_branch() is None
@@ -109,7 +109,7 @@ class TestRefs(TestBase):
             head.set_tracking_branch(None)
             assert head.tracking_branch() is None
         # END for each head
-        
+
         # verify REFLOG gets altered
         head = rwrepo.head
         cur_head = head.ref
@@ -123,50 +123,50 @@ class TestRefs(TestBase):
         assert len(thlog) == hlog_len + 1
         assert thlog[-1].oldhexsha == cur_commit.hexsha
         assert thlog[-1].newhexsha == pcommit.hexsha
-        
+
         # the ref didn't change though
         assert len(cur_head.log()) == blog_len
-        
+
         # head changes once again, cur_head doesn't change
         head.set_reference(cur_head, 'reattach head')
         assert len(head.log()) == hlog_len+2
         assert len(cur_head.log()) == blog_len
-        
+
         # adjusting the head-ref also adjust the head, so both reflogs are
         # altered
         cur_head.set_commit(pcommit, 'changing commit')
         assert len(cur_head.log()) == blog_len+1
         assert len(head.log()) == hlog_len+3
-        
-        
+
+
         # with automatic dereferencing
         assert head.set_commit(cur_commit, 'change commit once again') is head
         assert len(head.log()) == hlog_len+4
         assert len(cur_head.log()) == blog_len+2
-        
+
         # a new branch has just a single entry
         other_head = Head.create(rwrepo, 'mynewhead', pcommit, logmsg='new head created')
         log = other_head.log()
         assert len(log) == 1
         assert log[0].oldhexsha == pcommit.NULL_HEX_SHA
         assert log[0].newhexsha == pcommit.hexsha
-    
-        
+
+
     def test_refs(self):
         types_found = set()
         for ref in self.rorepo.refs:
             types_found.add(type(ref))
         assert len(types_found) >= 3 
-        
+
     def test_is_valid(self):
         assert Reference(self.rorepo, 'refs/doesnt/exist').is_valid() == False
         assert self.rorepo.head.is_valid()
         assert self.rorepo.head.reference.is_valid()
         assert SymbolicReference(self.rorepo, 'hellothere').is_valid() == False
-        
+
     def test_orig_head(self):
         assert type(self.rorepo.head.orig_head()) == SymbolicReference
-        
+
     @with_rw_repo('0.1.6')
     def test_head_reset(self, rw_repo):
         cur_head = rw_repo.head
@@ -174,24 +174,24 @@ class TestRefs(TestBase):
         new_head_commit = cur_head.ref.commit.parents[0]
         cur_head.reset(new_head_commit, index=True) # index only
         assert cur_head.reference.commit == new_head_commit
-        
+
         self.failUnlessRaises(ValueError, cur_head.reset, new_head_commit, index=False, working_tree=True)
         new_head_commit = new_head_commit.parents[0]
         cur_head.reset(new_head_commit, index=True, working_tree=True)  # index + wt
         assert cur_head.reference.commit == new_head_commit
-        
+
         # paths - make sure we have something to do
         rw_repo.index.reset(old_head_commit.parents[0])
         cur_head.reset(cur_head, paths = "test")
         cur_head.reset(new_head_commit, paths = "lib")
         # hard resets with paths don't work, its all or nothing
         self.failUnlessRaises(GitCommandError, cur_head.reset, new_head_commit, working_tree=True, paths = "lib")
-        
+
         # we can do a mixed reset, and then checkout from the index though
         cur_head.reset(new_head_commit)
         rw_repo.index.checkout(["lib"], force=True)#
-        
-        
+
+
         # now that we have a write write repo, change the HEAD reference - its 
         # like git-reset --soft
         heads = rw_repo.heads
@@ -203,7 +203,7 @@ class TestRefs(TestBase):
             assert cur_head.commit == head.commit
             assert not cur_head.is_detached
         # END for each head
-        
+
         # detach
         active_head = heads[0]
         curhead_commit = active_head.commit
@@ -211,20 +211,20 @@ class TestRefs(TestBase):
         assert cur_head.commit == curhead_commit
         assert cur_head.is_detached
         self.failUnlessRaises(TypeError, getattr, cur_head, "reference")
-        
+
         # tags are references, hence we can point to them
         some_tag = rw_repo.tags[0]
         cur_head.reference = some_tag
         assert not cur_head.is_detached
         assert cur_head.commit == some_tag.commit
         assert isinstance(cur_head.reference, TagReference) 
-        
+
         # put HEAD back to a real head, otherwise everything else fails
         cur_head.reference = active_head
-        
+
         # type check
         self.failUnlessRaises(ValueError, setattr, cur_head, "reference", "that")
-        
+
         # head handling 
         commit = 'HEAD'
         prev_head_commit = cur_head.commit
@@ -236,25 +236,25 @@ class TestRefs(TestBase):
             assert isinstance(new_head, Head)
             # already exists, but has the same value, so its fine
             Head.create(rw_repo, new_name, new_head.commit)
-            
+
             # its not fine with a different value
             self.failUnlessRaises(OSError, Head.create, rw_repo, new_name, new_head.commit.parents[0])
-            
+
             # force it
             new_head = Head.create(rw_repo, new_name, actual_commit, force=True)
             old_path = new_head.path
             old_name = new_head.name
-            
+
             assert new_head.rename("hello").name == "hello"
             assert new_head.rename("hello/world").name == "hello/world"
             assert new_head.rename(old_name).name == old_name and new_head.path == old_path
-            
+
             # rename with force
             tmp_head = Head.create(rw_repo, "tmphead")
             self.failUnlessRaises(GitCommandError, tmp_head.rename, new_head)
             tmp_head.rename(new_head, force=True)
             assert tmp_head == new_head and tmp_head.object == new_head.object
-            
+
             logfile = RefLog.path(tmp_head)
             assert os.path.isfile(logfile)
             Head.delete(rw_repo, tmp_head)
@@ -265,7 +265,7 @@ class TestRefs(TestBase):
             # force on deletion testing would be missing here, code looks okay though ;)
         # END for each new head name
         self.failUnlessRaises(TypeError, RemoteReference.create, rw_repo, "some_name")
-        
+
         # tag ref
         tag_name = "1.0.2"
         light_tag = TagReference.create(rw_repo, tag_name)
@@ -275,7 +275,7 @@ class TestRefs(TestBase):
         assert light_tag.name == tag_name
         assert light_tag.commit == cur_head.commit.parents[0]
         assert light_tag.tag is None
-        
+
         # tag with tag object
         other_tag_name = "releases/1.0.2RC"
         msg = "my mighty tag\nsecond line"
@@ -284,18 +284,18 @@ class TestRefs(TestBase):
         assert obj_tag.name == other_tag_name
         assert obj_tag.commit == cur_head.commit
         assert obj_tag.tag is not None
-        
+
         TagReference.delete(rw_repo, light_tag, obj_tag)
         tags = rw_repo.tags
         assert light_tag not in tags and obj_tag not in tags
-        
+
         # remote deletion
         remote_refs_so_far = 0
         remotes = rw_repo.remotes 
         assert remotes
         for remote in remotes:
             refs = remote.refs
-            
+
             # If a HEAD exists, it must be deleted first. Otherwise it might
             # end up pointing to an invalid ref it the ref was deleted before.
             remote_head_name = "HEAD"
@@ -303,30 +303,30 @@ class TestRefs(TestBase):
                 RemoteReference.delete(rw_repo, refs[remote_head_name])
                 del(refs[remote_head_name])
             #END handle HEAD deletion
-            
+
             RemoteReference.delete(rw_repo, *refs)
             remote_refs_so_far += len(refs)
             for ref in refs:
                 assert ref.remote_name == remote.name
         # END for each ref to delete
         assert remote_refs_so_far
-        
+
         for remote in remotes:
             # remotes without references throw
             self.failUnlessRaises(AssertionError, getattr, remote, 'refs')
         # END for each remote
-        
+
         # change where the active head points to
         if cur_head.is_detached:
             cur_head.reference = rw_repo.heads[0]
-        
+
         head = cur_head.reference
         old_commit = head.commit
         head.commit = old_commit.parents[0]
         assert head.commit == old_commit.parents[0]
         assert head.commit == cur_head.commit
         head.commit = old_commit
-        
+
         # setting a non-commit as commit fails, but succeeds as object
         head_tree = head.commit.tree
         self.failUnlessRaises(ValueError, setattr, head, 'commit', head_tree)
@@ -336,7 +336,7 @@ class TestRefs(TestBase):
         assert head.object == head_tree
         # cannot query tree as commit
         self.failUnlessRaises(TypeError, getattr, head, 'commit') 
-        
+
         # set the commit directly using the head. This would never detach the head
         assert not cur_head.is_detached
         head.object = old_commit
@@ -346,58 +346,58 @@ class TestRefs(TestBase):
         assert cur_head.is_detached
         cur_head.commit = parent_commit
         assert cur_head.is_detached and cur_head.commit == parent_commit
-        
+
         cur_head.reference = head
         assert not cur_head.is_detached
         cur_head.commit = parent_commit
         assert not cur_head.is_detached
         assert head.commit == parent_commit
-        
+
         # test checkout
         active_branch = rw_repo.active_branch
         for head in rw_repo.heads:
             checked_out_head = head.checkout()
             assert checked_out_head == head
         # END for each head to checkout
-        
+
         # checkout with branch creation
         new_head = active_branch.checkout(b="new_head")
         assert active_branch != rw_repo.active_branch
         assert new_head == rw_repo.active_branch
-        
+
         # checkout  with force as we have a changed a file
         # clear file
         open(new_head.commit.tree.blobs[-1].abspath,'w').close()
         assert len(new_head.commit.diff(None))
-        
+
         # create a new branch that is likely to touch the file we changed
         far_away_head = rw_repo.create_head("far_head",'HEAD~100')
         self.failUnlessRaises(GitCommandError, far_away_head.checkout)
         assert active_branch == active_branch.checkout(force=True)
         assert rw_repo.head.reference != far_away_head
-        
+
         # test reference creation
         partial_ref = 'sub/ref'
         full_ref = 'refs/%s' % partial_ref
         ref = Reference.create(rw_repo, partial_ref)
         assert ref.path == full_ref
         assert ref.object == rw_repo.head.commit
-        
+
         self.failUnlessRaises(OSError, Reference.create, rw_repo, full_ref, 'HEAD~20')
         # it works if it is at the same spot though and points to the same reference
         assert Reference.create(rw_repo, full_ref, 'HEAD').path == full_ref
         Reference.delete(rw_repo, full_ref)
-        
+
         # recreate the reference using a full_ref
         ref = Reference.create(rw_repo, full_ref)
         assert ref.path == full_ref
         assert ref.object == rw_repo.head.commit
-        
+
         # recreate using force
         ref = Reference.create(rw_repo, partial_ref, 'HEAD~1', force=True)
         assert ref.path == full_ref
         assert ref.object == rw_repo.head.commit.parents[0]
-        
+
         # rename it
         orig_obj = ref.object
         for name in ('refs/absname', 'rela_name', 'feature/rela_name'):
@@ -407,10 +407,10 @@ class TestRefs(TestBase):
             assert ref_new_name.object == orig_obj
             assert ref_new_name == ref
         # END for each name type
-        
+
         # References that don't exist trigger an error if we want to access them
         self.failUnlessRaises(ValueError, getattr, Reference(rw_repo, "refs/doesntexist"), 'commit')
-        
+
         # exists, fail unless we force
         ex_ref_path = far_away_head.path
         self.failUnlessRaises(OSError, ref.rename, ex_ref_path)
@@ -419,33 +419,33 @@ class TestRefs(TestBase):
         ref.rename(ex_ref_path)
         assert ref.path == ex_ref_path and ref.object == orig_obj
         assert ref.rename(ref.path).path == ex_ref_path # rename to same name
-        
+
         # create symbolic refs
         symref_path = "symrefs/sym"
         symref = SymbolicReference.create(rw_repo, symref_path, cur_head.reference)
         assert symref.path == symref_path
         assert symref.reference == cur_head.reference
-        
+
         self.failUnlessRaises(OSError, SymbolicReference.create, rw_repo, symref_path, cur_head.reference.commit)
         # it works if the new ref points to the same reference 
         SymbolicReference.create(rw_repo, symref.path, symref.reference).path == symref.path
         SymbolicReference.delete(rw_repo, symref)
         # would raise if the symref wouldn't have been deletedpbl
         symref = SymbolicReference.create(rw_repo, symref_path, cur_head.reference)
-        
+
         # test symbolic references which are not at default locations like HEAD
         # or FETCH_HEAD - they may also be at spots in refs of course
         symbol_ref_path = "refs/symbol_ref"
         symref = SymbolicReference(rw_repo, symbol_ref_path)
         assert symref.path == symbol_ref_path
         symbol_ref_abspath = os.path.join(rw_repo.git_dir, symref.path)
-        
+
         # set it
         symref.reference = new_head
         assert symref.reference == new_head
         assert os.path.isfile(symbol_ref_abspath)
         assert symref.commit == new_head.commit
-        
+
         for name in ('absname','folder/rela_name'):
             symref_new_name = symref.rename(name)
             assert isinstance(symref_new_name, SymbolicReference)
@@ -454,10 +454,10 @@ class TestRefs(TestBase):
             assert symref_new_name == symref
             assert not symref.is_detached
         # END for each ref
-        
+
         # create a new non-head ref just to be sure we handle it even if packed
         Reference.create(rw_repo, full_ref)
-        
+
         # test ref listing - assure we have packed refs
         rw_repo.git.pack_refs(all=True, prune=True)
         heads = rw_repo.heads
@@ -465,12 +465,12 @@ class TestRefs(TestBase):
         assert new_head in heads
         assert active_branch in heads
         assert rw_repo.tags
-        
+
         # we should be able to iterate all symbolic refs as well - in that case
         # we should expect only symbolic references to be returned
         for symref in SymbolicReference.iter_items(rw_repo):
             assert not symref.is_detached
-            
+
         # when iterating references, we can get references and symrefs
         # when deleting all refs, I'd expect them to be gone ! Even from 
         # the packed ones
@@ -484,22 +484,22 @@ class TestRefs(TestBase):
             # END delete ref
         # END for each ref to iterate and to delete
         assert deleted_refs
-        
+
         for ref in Reference.iter_items(rw_repo):
             if ref.is_detached:
                 assert ref not in deleted_refs
         # END for each ref
-        
+
         # reattach head - head will not be returned if it is not a symbolic 
         # ref
         rw_repo.head.reference = Head.create(rw_repo, "master")
-        
+
         # At least the head should still exist
         assert os.path.isfile(os.path.join(rw_repo.git_dir, 'HEAD'))
         refs = list(SymbolicReference.iter_items(rw_repo))
         assert len(refs) == 1
-        
-        
+
+
         # test creation of new refs from scratch
         for path in ("basename", "dir/somename", "dir2/subdir/basename"):
             # REFERENCES 
@@ -509,37 +509,36 @@ class TestRefs(TestBase):
             assert not ref_fp.is_valid()
             ref = Reference(rw_repo, fpath)
             assert ref == ref_fp
-            
+
             # can be created by assigning a commit
             ref.commit = rw_repo.head.commit
             assert ref.is_valid()
-            
+
             # if the assignment raises, the ref doesn't exist
             Reference.delete(ref.repo, ref.path)
             assert not ref.is_valid()
             self.failUnlessRaises(ValueError, setattr, ref, 'commit', "nonsense")
             assert not ref.is_valid()
-            
+
             # I am sure I had my reason to make it a class method at first, but
             # now it doesn't make so much sense anymore, want an instance method as well
             # See http://byronimo.lighthouseapp.com/projects/51787-gitpython/tickets/27
             Reference.delete(ref.repo, ref.path)
             assert not ref.is_valid()
-            
+
             ref.object = rw_repo.head.commit
             assert ref.is_valid()
-            
+
             Reference.delete(ref.repo, ref.path)
             assert not ref.is_valid()
             self.failUnlessRaises(ValueError, setattr, ref, 'object', "nonsense")
             assert not ref.is_valid()
-            
+
         # END for each path
-        
+
     def test_dereference_recursive(self):
         # for now, just test the HEAD
         assert SymbolicReference.dereference_recursive(self.rorepo, 'HEAD')
-        
+
     def test_reflog(self):
         assert isinstance(self.rorepo.heads.master.log(), RefLog)
-