Fixes trailing whitespace

Author: Matt-Deacalion

.travis.yml

@@ -10,6 +10,6 @@ notifications:
 
 # Some other koans (see runner/sensei.py or "ls koans" to see the light):
 #
-# about_none about_lists about_list_assignments about_dictionaries 
-# about_strings about_tuples about_methods about_control_statements 
+# about_none about_lists about_list_assignments about_dictionaries
+# about_strings about_tuples about_methods about_control_statements
 # about_true_and_false about_sets ...

Contributor Notes.txt

@@ -9,7 +9,7 @@ Running a whole test case:
   $ python contemplate_koans.py about_strings
   or
   $ python3 contemplate_koans.py about_strings
-  
+
   Running a single test:
 
   $ python contemplate_koans.py about_strings.AboutStrings.test_triple_quoted_strings_need_less_escaping

README.rst

@@ -6,7 +6,7 @@ Python Koans is a port of Edgecase's "Ruby Koans".
 
 .. image:: http://i442.photobucket.com/albums/qq150/gregmalcolm/PythonKoansScreenshot.png
 
-Python Koans is an interactive tutorial for learning Python by making tests pass. 
+Python Koans is an interactive tutorial for learning Python by making tests pass.
 
 Most tests are 'fixed' by filling the missing parts of assert functions. Eg:
 
@@ -40,7 +40,7 @@ Installing Python Koans
 
 Aside from downloading or checking out the latest version of Python Koans, all you need to install is Python.
 
-At this time of writing there are two versions of the koans, one for use with Python 2.6 and one for Python 3.1. You should be able to work with newer Python versions, but older ones will likely give you problems. 
+At this time of writing there are two versions of the koans, one for use with Python 2.6 and one for Python 3.1. You should be able to work with newer Python versions, but older ones will likely give you problems.
 
 You can download Python from here:
 
@@ -99,11 +99,11 @@ Getting the Most From the Koans
 
 Quoting the Ruby Koans instructions::
 
-	"In test-driven development the mantra has always been, red, green, 
+	"In test-driven development the mantra has always been, red, green,
 	refactor. Write a failing test and run it (red), make the test pass
 	(green), then refactor it (that is look at the code and see if you
 	can make it any better. In this case you will need to run the koan
-	and see it fail (red), make the test pass (green), then take a 
+	and see it fail (red), make the test pass (green), then take a
 	moment and reflect upon the test to see what it is teaching you
 	and improve the code to better communicate its intent (refactor)."
 

python2/_runner_tests.py

@@ -17,4 +17,3 @@ def suite():
 
 if __name__ == '__main__':
     unittest.TextTestRunner(verbosity=2).run(suite())
-    

python2/contemplate_koans.py

@@ -14,7 +14,7 @@
 import sys
 
 
-if __name__ == '__main__':        
+if __name__ == '__main__':
     if sys.version_info >= (3, 0):
         print("\nThis is the Python 2 version of Python Koans, but you are " +
             "running it with Python 3 or newer!\n\n"
@@ -31,7 +31,7 @@
                 "to work!\n\n" +
                 "But lets see how far we get...\n" +
                 "********************************************************\n")
-        
+
         from runner.mountain import Mountain
 
         Mountain().walk_the_path(sys.argv)

python2/koans/about_decorating_with_classes.py

@@ -19,10 +19,10 @@ def test_partial_that_wrappers_no_args(self):
         the partial.
         """
         max = functools.partial(self.maximum)
-        
+
         self.assertEqual(__, max(7, 23))
         self.assertEqual(__, max(10, -10))
-        
+
     def test_partial_that_wrappers_first_arg(self):
         max0 = functools.partial(self.maximum, 0)
 
@@ -41,10 +41,10 @@ def test_partial_that_wrappers_all_args(self):
     class doubleit(object):
         def __init__(self, fn):
             self.fn = fn
-    
+
         def __call__(self, *args):
             return self.fn(*args) + ', ' + self.fn(*args)
-    
+
         def __get__(self, obj, cls=None):
             if not obj:
                 # Decorating an unbound function
@@ -56,15 +56,15 @@ def __get__(self, obj, cls=None):
     @doubleit
     def foo(self):
         return "foo"
-    
+
     @doubleit
     def parrot(self, text):
         return text.upper()
-                
+
     def test_decorator_with_no_arguments(self):
         # To clarify: the decorator above the function has no arguments, even
         # if the decorated function does
-                
+
         self.assertEqual(__, self.foo())
         self.assertEqual(__, self.parrot('pieces of eight'))
 
@@ -77,25 +77,25 @@ def sound_check(self):
     def test_what_a_decorator_is_doing_to_a_function(self):
         #wrap the function with the decorator
         self.sound_check = self.doubleit(self.sound_check)
-        
+
         self.assertEqual(__, self.sound_check())
 
     # ------------------------------------------------------------------
 
     class documenter(object):
         def __init__(self, *args):
             self.fn_doc = args[0]
-    
+
         def __call__(self, fn):
             def decorated_function(*args):
                 return fn(*args)
-                
+
             if fn.__doc__:
                 decorated_function.__doc__ = fn.__doc__ + ": " + self.fn_doc
             else:
                 decorated_function.__doc__ = self.fn_doc
             return decorated_function
-        
+
     @documenter("Increments a value by one. Kind of.")
     def count_badly(self, num):
         num += 1
@@ -117,7 +117,7 @@ def test_documentor_which_already_has_a_docstring(self):
         self.assertEqual(__, self.idler.__doc__)
 
     # ------------------------------------------------------------------
-        
+
     @documenter("DOH!")
     @doubleit
     @doubleit

python2/koans/about_decorating_with_functions.py

@@ -3,30 +3,30 @@
 
 from runner.koan import *
 
-            
+
 class AboutDecoratingWithFunctions(Koan):
     def addcowbell(fn):
         fn.wow_factor = 'COWBELL BABY!'
         return fn
-            
+
     @addcowbell
     def mediocre_song(self):
         return "o/~ We all live in a broken submarine o/~"
-                
+
     def test_decorators_can_modify_a_function(self):
         self.assertMatch(__, self.mediocre_song())
         self.assertEqual(__, self.mediocre_song.wow_factor)
-    
+
     # ------------------------------------------------------------------
 
     def xmltag(fn):
         def func(*args):
             return '<' + fn(*args) + '/>'
         return func
-            
+
     @xmltag
     def render_tag(self, name):
         return name
-    
+
     def test_decorators_can_change_a_function_output(self):
         self.assertEqual(__, self.render_tag('llama'))

python2/koans/about_deleting_objects.py

@@ -9,9 +9,9 @@ def test_del_can_remove_slices(self):
         lottery_nums = [4, 8, 15, 16, 23, 42]
         del lottery_nums[1]
         del lottery_nums[2:4]
-        
+
         self.assertEqual(__, lottery_nums)
-        
+
     def test_del_can_remove_entire_lists(self):
         lottery_nums = [4, 8, 15, 16, 23, 42]
         del lottery_nums
@@ -20,28 +20,28 @@ def test_del_can_remove_entire_lists(self):
         except Exception as e:
             pass
         self.assertMatch(__, e[0])
-        
+
     # --------------------------------------------------------------------
-        
+
     class ClosingSale(object):
         def __init__(self):
             self.hamsters = 7
             self.zebras = 84
-            
+
         def cameras(self):
             return 34
-        
+
         def toilet_brushes(self):
             return 48
-        
+
         def jellies(self):
             return 5
-        
+
     def test_del_can_remove_attributes(self):
         crazy_discounts = self.ClosingSale()
         del self.ClosingSale.toilet_brushes
         del crazy_discounts.hamsters
-        
+
         try:
             still_available = crazy_discounts.toilet_brushes()
         except AttributeError as e:
@@ -51,7 +51,7 @@ def test_del_can_remove_attributes(self):
             still_available = crazy_discounts.hamsters
         except AttributeError as e:
             err_msg2 = e.args[0]
-        
+
         self.assertMatch(__, err_msg1)
         self.assertMatch(__, err_msg2)
 
@@ -60,7 +60,7 @@ def test_del_can_remove_attributes(self):
     class ClintEastwood(object):
         def __init__(self):
             self._name = None
-            
+
         def get_name(self):
             try:
                 return self._name
@@ -69,39 +69,39 @@ def get_name(self):
 
         def set_name(self, name):
             self._name = name
-            
+
         def del_name(self):
             del self._name
-            
+
         name = property(get_name, set_name, del_name, \
             "Mr Eastwood's current alias")
-            
+
     def test_del_works_with_properties(self):
         cowboy = self.ClintEastwood()
         cowboy.name = 'Senor Ninguno'
         self.assertEqual('Senor Ninguno', cowboy.name)
 
         del cowboy.name
         self.assertEqual(__, cowboy.name)
-        
+
     # --------------------------------------------------------------------
 
     class Prisoner(object):
         def __init__(self):
             self._name = None
-        
+
         @property
         def name(self):
             return self._name
 
         @name.setter
         def name(self, name):
             self._name = name
-            
+
         @name.deleter
         def name(self):
             self._name = 'Number Six'
-                        
+
     def test_another_way_to_make_a_deletable_property(self):
         citizen = self.Prisoner()
         citizen.name = "Patrick"
@@ -111,12 +111,12 @@ def test_another_way_to_make_a_deletable_property(self):
         self.assertEqual(__, citizen.name)
 
     # --------------------------------------------------------------------
-        
+
     class MoreOrganisedClosingSale(ClosingSale):
         def __init__(self):
             self.last_deletion = None
             super(AboutDeletingObjects.ClosingSale, self).__init__()
-        
+
         def __delattr__(self, attr_name):
             self.last_deletion = attr_name
 

python2/koans/about_dice_project.py

@@ -9,11 +9,11 @@
 class DiceSet(object):
     def __init__(self):
         self._values = None
-    
+
     @property
     def values(self):
         return self._values
-              
+
     def roll(self, n):
         # Needs implementing!
         # Tip: random.randint(min, max) can be used to generate random numbers
@@ -27,45 +27,45 @@ def test_can_create_a_dice_set(self):
 
     def test_rolling_the_dice_returns_a_set_of_integers_between_1_and_6(self):
         dice = DiceSet()
-        
+
         dice.roll(5)
         self.assertTrue(isinstance(dice.values, list), "should be a list")
         self.assertEqual(5, len(dice.values))
         for value in dice.values:
             self.assertTrue(
                 value >= 1 and value <= 6,
                 "value " + str(value) + " must be between 1 and 6")
-        
+
     def test_dice_values_do_not_change_unless_explicitly_rolled(self):
         dice = DiceSet()
         dice.roll(5)
         first_time = dice.values
         second_time = dice.values
         self.assertEqual(first_time, second_time)
-        
+
     def test_dice_values_should_change_between_rolls(self):
         dice = DiceSet()
-        
+
         dice.roll(5)
         first_time = dice.values
-        
+
         dice.roll(5)
         second_time = dice.values
-        
+
         self.assertNotEqual(first_time, second_time, \
             "Two rolls should not be equal")
-        
+
         # THINK ABOUT IT:
         #
         # If the rolls are random, then it is possible (although not
         # likely) that two consecutive rolls are equal.  What would be a
         # better way to test this?
-        
+
     def test_you_can_roll_different_numbers_of_dice(self):
         dice = DiceSet()
-        
+
         dice.roll(3)
         self.assertEqual(3, len(dice.values))
-        
+
         dice.roll(1)
         self.assertEqual(1, len(dice.values))