Merged src directory with existing koans.

koans/GREED_RULES.txt

@@ -1,12 +1,12 @@
 = Playing Greed
 
-Greed is a dice game played among 2 or more players, using 5
+Greed is a dice game played amoung 2 or more players, using 5
 six-sided dice.
 
 == Playing Greed
 
 Each player takes a turn consisting of one or more rolls of the dice.
-On the first roll of the game, a player rolls all five dice which are
+On the first roll of the game, a player rolls all six dice which are
 scored according to the following:
 
   Three 1's => 1000 points
@@ -37,7 +37,7 @@ final example.
 
 After a player rolls and the score is calculated, the scoring dice are
 removed and the player has the option of rolling again using only the
-non-scoring dice. If all of the dice are scoring, then the player
+non-scoring dice. If there all no non-scoring dice), then the player
 may roll all 5 dice in the next roll.
 
 The player may continue to roll as long as each roll scores points. If

koans/about_arrays.rb

@@ -40,6 +40,7 @@ class AboutArrays < EdgeCase::Koan
     assert_equal __, array[2,2]
     assert_equal __, array[2,20]
     assert_equal __, array[4,0]
+    assert_equal __, array[4,100]
     assert_equal __, array[5,0]
   end
 

koans/about_asserts.rb

@@ -7,7 +7,7 @@ class AboutAsserts < EdgeCase::Koan
 
   # We shall contemplate truth by testing reality, via asserts.
   def test_assert_truth
-    assert false                # This should be true
+    assert true                 # This should be true
   end
 
   # Enlightenment may be more easily achieved with appropriate
@@ -19,7 +19,7 @@ class AboutAsserts < EdgeCase::Koan
   # To understand reality, we must compare our expectations against
   # reality.
   def test_assert_equality
-    expected_value = 3
+    expected_value = __
     actual_value = 1 + 1
 
     assert expected_value == actual_value
@@ -27,7 +27,7 @@ class AboutAsserts < EdgeCase::Koan
 
   # Some ways of asserting equality are better than others.
   def test_a_better_way_of_asserting_equality
-    expected_value = 3
+    expected_value = __
     actual_value = 1 + 1
 
     assert_equal expected_value, actual_value

koans/about_blocks.rb

@@ -77,7 +77,7 @@ class AboutBlocks < EdgeCase::Koan
   def test_stand_alone_blocks_can_be_passed_to_methods_expecting_blocks
     make_upper = lambda { |n| n.upcase }
     result = method_with_block_arguments(&make_upper)
-    assert_equal __, result    
+    assert_equal __, result
   end
 
   # ------------------------------------------------------------------

koans/about_control_statements.rb

@@ -11,7 +11,7 @@ class AboutControlStatements < EdgeCase::Koan
     assert_equal __, result
   end
 
-  def test_if_then_statements
+  def test_if_then_else_statements
     result = :default_value
     if true
       result = :true_value

koans/about_exceptions.rb

@@ -6,10 +6,10 @@ class AboutExceptions < EdgeCase::Koan
   end
 
   def test_exceptions_inherit_from_Exception
-    assert MySpecialError.ancestors.include?(RuntimeError)
-    assert MySpecialError.ancestors.include?(StandardError)
-    assert MySpecialError.ancestors.include?(Exception)
-    assert MySpecialError.ancestors.include?(Object)
+    assert_equal __, MySpecialError.ancestors[1]
+    assert_equal __, MySpecialError.ancestors[2]
+    assert_equal __, MySpecialError.ancestors[3]
+    assert_equal __, MySpecialError.ancestors[4]
   end
 
   def test_rescue_clause
@@ -40,7 +40,7 @@ class AboutExceptions < EdgeCase::Koan
       result = :exception_handled
     end
 
-    assert_equal __(:exception_handled), result
+    assert_equal __, result
     assert_equal __, ex.message
   end
 

koans/about_hashes.rb

@@ -35,14 +35,23 @@ class AboutHashes < EdgeCase::Koan
     hash1 = { :one => "uno", :two => "dos" }
     hash2 = { :two => "dos", :one => "uno" }
 
-    assert_equal hash1, hash2    
+    assert_equal hash1, hash2
   end
 
-  def test_hash_keys_and_values
+  def test_hash_keys
     hash = { :one => "uno", :two => "dos" }
+    assert_equal __, hash.keys.size
+    assert_equal __, hash.keys.include?(:one)
+    assert_equal __, hash.keys.include?(:two)
+    assert_equal Array, hash.keys.class
+  end
 
-    assert_equal __, hash.keys.sort
-    assert_equal __, hash.values.sort
+  def test_hash_values
+    hash = { :one => "uno", :two => "dos" }
+    assert_equal __, hash.keys.size
+    assert_equal __, hash.values.include?("uno")
+    assert_equal __, hash.values.include?("dos")
+    assert_equal Array, hash.values.class
   end
 
   def test_combining_hashes

koans/about_message_passing.rb

@@ -25,7 +25,7 @@ class AboutMessagePassing < EdgeCase::Koan
     
     assert mc.send("caught?")
     assert mc.send("caught" + __ )    # What do you need to add to the first string?
-    assert mc.send("CAUGHT?".__ )      # What would you need to do to the string?
+    assert mc.send("CAUGHT?".____ )      # What would you need to do to the string?
   end
 
   def test_send_with_underscores_will_also_send_messages
@@ -96,7 +96,7 @@ class AboutMessagePassing < EdgeCase::Koan
 
   class AllMessageCatcher
     def method_missing(method_name, *args, &block)
-      "Someone called #{method_name} with (#{args.join(", ")})"
+      "Someone called #{method_name} with <#{args.join(", ")}>"
     end
   end
 

koans/about_methods.rb

@@ -18,7 +18,7 @@ class AboutMethods < EdgeCase::Koan
   # (NOTE: We are Using eval below because the example code is
   # considered to be syntactically invalid).
   def test_sometimes_missing_parenthesis_are_ambiguous
-    eval "assert_equal 5, my_global_method 2, 3"
+    eval "assert_equal 5, my_global_method 2, 3" # ENABLE CHECK
     #
     # Ruby doesn't know if you mean:
     #
@@ -36,12 +36,12 @@ class AboutMethods < EdgeCase::Koan
     exception = assert_raise(___) do
       my_global_method
     end
-    assert_equal __, exception.message
+    assert_match(/__/, exception.message)
 
     exception = assert_raise(___) do
       my_global_method(1,2,3)
     end
-    assert_equal __, exception.message
+    assert_match(/__/, exception.message)
   end
 
   # ------------------------------------------------------------------

koans/about_nil.rb

@@ -2,34 +2,23 @@ require 'edgecase'
 
 class AboutNil < EdgeCase::Koan
   def test_nil_is_an_object
-    #  
-    #  Hint:  '!'s negate the response from what follows.
-    #
-    assert !nil.is_a?(Object), "Unlike NULL in other languages"
+    assert_equal __, nil.is_a?(Object), "Unlike NULL in other languages"
   end
 
   def test_you_dont_get_null_pointer_errors_when_calling_methods_on_nil
-    #
-    #  What is the Exception that is thrown when you call a method that
-    #  does not exist?  
-    #
-    #  Hint:  launch irb and try the code in the block below.  
-    # 
-    #  Don't be confused by the code below yet.  It's using blocks 
-    #  which are explained later on in about_blocks.rb.  For now,
-    #  think about it like running nil.some_method_nil_doesnt_know_about
-    #  in a sandbox and catching the error class into the exception
-    #  variable.  
-    #
-    exception = assert_raise(___) do
+    # What happens when you call a method that doesn't exist.  The
+    # following begin/rescue/end code block captures the exception and
+    # make some assertions about it.
+    begin
       nil.some_method_nil_doesnt_know_about
+    rescue Exception => ex
+      # What exception has been caught?
+      assert_equal __, ex.class
+
+      # What message was attached to the exception?
+      # (HINT: replace __ with part of the error message.)
+      assert_match(/__/, ex.message)
     end
-    
-    # 
-    #  What is the error message itself? What substring or pattern could 
-    #  you test against in order to have a good idea what the string is?
-    #  
-    assert_match /__/, exception.message
   end
 
   def test_nil_has_a_few_methods_defined_on_it

koans/about_proxy_object_project.rb

@@ -15,7 +15,10 @@ require 'edgecase'
 class Proxy
   def initialize(target_object)
     @object = target_object
+    # ADD MORE CODE HERE
   end
+
+  # WRITE CODE HERE
 end
 
 # The proxy object should pass the following Koan:

koans/code_mash.rb

@@ -1 +1 @@
-require 'edgecase'
+require 'edgecase'

koans/edgecase.rb

@@ -14,6 +14,14 @@ def ___(value=FillMeInError)
   value
 end
 
+class Object
+  def ____(method=nil)
+    if method
+      self.send(method)
+    end
+  end
+end
+
 module EdgeCase
   class Sensei
     attr_reader :failure, :failed_test

koans/path_to_enlightenment.rb

@@ -17,6 +17,7 @@ require 'about_blocks'
 require 'about_sandwich_code'
 require 'about_scoring_project'
 require 'about_classes'
+require 'about_open_classes'
 require 'about_dice_project'
 require 'about_inheritance'
 require 'about_modules'

src/about_arrays.rb

@@ -42,7 +42,6 @@ class AboutArrays < EdgeCase::Koan
     assert_equal __([]), array[4,0]
     assert_equal __([]), array[4,100]
     assert_equal __(nil), array[5,0]
-    assert_equal __(nil), array[5,0]
   end
 
   def test_arrays_and_ranges
@@ -57,7 +56,7 @@ class AboutArrays < EdgeCase::Koan
 
     assert_equal __([:peanut, :butter, :and]), array[0..2]
     assert_equal __([:peanut, :butter]), array[0...2]
-    assert_equal ([:and, :jelly]), array[2..-1]
+    assert_equal __([:and, :jelly]), array[2..-1]
   end
 
   def test_pushing_and_popping_arrays

src/about_asserts.rb

@@ -7,13 +7,13 @@ class AboutAsserts < EdgeCase::Koan
 
   # We shall contemplate truth by testing reality, via asserts.
   def test_assert_truth
-    assert __(true)             # This should be true
+    assert true                 # This should be true
   end
 
   # Enlightenment may be more easily achieved with appropriate
   # messages.
   def test_assert_with_message
-    assert __(true), "This should be true -- Please fix this"
+    assert false, "This should be true -- Please fix this"
   end
 
   # To understand reality, we must compare our expectations against

src/about_class_methods.rb

@@ -19,11 +19,11 @@ class AboutClassMethods < EdgeCase::Koan
 
   def test_objects_have_methods
     fido = Dog.new
-    assert_equal __(45), fido.methods.size
+    assert_equal __(44), fido.methods.size
   end
 
   def test_classes_have_methods
-    assert_equal __(80), Dog.methods.size
+    assert_equal __(79), Dog.methods.size
   end
 
   def test_you_can_define_methods_on_individual_objects
@@ -34,9 +34,12 @@ class AboutClassMethods < EdgeCase::Koan
     assert_equal __(:fidos_wag), fido.wag
   end
 
-  def test_other_objects_are_unaffected_by_these_singleton_methods
+  def test_other_objects_are_not_affected_by_these_singleton_methods
     fido = Dog.new
     rover = Dog.new
+    def fido.wag
+      :fidos_wag
+    end
 
     assert_raise(___(NoMethodError)) do
       rover.wag
@@ -45,24 +48,24 @@ class AboutClassMethods < EdgeCase::Koan
 
   # ------------------------------------------------------------------
   
-  def Dog.bark
-    :class_level_bark
-  end
-
-  class Dog
-    def bark
-      :instance_level_bark
+  class Dog2
+    def wag
+      :instance_level_wag
     end
   end
 
+  def Dog2.wag
+    :class_level_wag
+  end
+
   def test_since_classes_are_objects_you_can_define_singleton_methods_on_them_too
-    assert_equal __(:class_level_bark), Dog.bark
+    assert_equal __(:class_level_wag), Dog2.wag
   end
 
   def test_class_methods_are_independent_of_instance_methods
-    fido = Dog.new
-    assert_equal __(:instance_level_bark), fido.bark
-    assert_equal __(:class_level_bark), Dog.bark
+    fido = Dog2.new
+    assert_equal __(:instance_level_wag), fido.wag
+    assert_equal __(:class_level_wag), Dog2.wag
   end
 
   # ------------------------------------------------------------------
@@ -155,7 +158,7 @@ class AboutClassMethods < EdgeCase::Koan
   #   end
   #
   # Which do you prefer and why?
-  # Are there times you might prefer the other way?
+  # Are there times you might prefer one over the other?
 
   # ------------------------------------------------------------------
 

src/about_methods.rb

@@ -79,7 +79,7 @@ class AboutMethods < EdgeCase::Koan
   def method_with_explicit_return
     :a_non_return_value
     return :return_value
-    :anoher_non_return_value
+    :another_non_return_value
   end
 
   def test_method_with_explicit_return

src/about_scoring_project.rb

@@ -25,7 +25,7 @@ require 'edgecase'
 # score([3,4,5,3,3]) => 350 points
 # score([1,5,1,2,4]) => 250 points
 #
-# More scoing examples are given in the tests below:
+# More scoring examples are given in the tests below:
 #
 # Your goal is to write the score method.
 

src/about_strings.rb

@@ -128,7 +128,7 @@ EOS
     assert_equal __('The value is #{value}'), string
   end
 
-  def test_any_ruby_expression_my_be_interpolated
+  def test_any_ruby_expression_may_be_interpolated
     string = "The square root of 5 is #{Math.sqrt(5)}"
     assert_equal __("The square root of 5 is 2.23606797749979"), string
   end

src/about_triangle_project_2.rb

@@ -3,7 +3,7 @@ require 'edgecase'
 # You need to write the triangle method in the file 'triangle.rb'
 require 'triangle.rb'
 
-class AboutTriangleAssignment < EdgeCase::Koan
+class AboutTriangleAssignment2 < EdgeCase::Koan
   # The first assignment did not talk about how to handle errors.
   # Let's handle that part now.
   def test_illegal_triangles_throw_exceptions