From: Jim Weirich Date: Tue, 28 Sep 2010 18:17:46 +0000 (-0400) Subject: Updated koans from src. X-Git-Tag: rubykoans-2010-11-29~11 X-Git-Url: https://git.eng.unimelb.edu.au/public?a=commitdiff_plain;h=b41d6167b433ed5c27e65e8f838a33fd80b0e5e2;p=ruby_koans.git Updated koans from src. --- diff --git a/koans/about_array_assignment.rb b/koans/about_array_assignment.rb index 12733fb..71efb16 100644 --- a/koans/about_array_assignment.rb +++ b/koans/about_array_assignment.rb @@ -5,7 +5,7 @@ class AboutArrayAssignment < EdgeCase::Koan names = ["John", "Smith"] assert_equal __, names end - + def test_parallel_assignments first_name, last_name = ["John", "Smith"] assert_equal __, first_name @@ -18,13 +18,19 @@ class AboutArrayAssignment < EdgeCase::Koan assert_equal __, last_name end - def test_parallel_assignments_with_extra_variables + def test_parallel_assignments_with_splat_operator + first_name, *last_name = ["John", "Smith", "III"] + assert_equal "John", first_name + assert_equal ["Smith","III"], last_name + end + + def test_parallel_assignments_with_too_few_variables first_name, last_name = ["Cher"] assert_equal __, first_name assert_equal __, last_name end - def test_parallel_assignements_with_subarrays + def test_parallel_assignments_with_subarrays first_name, last_name = [["Willie", "Rae"], "Johnson"] assert_equal __, first_name assert_equal __, last_name diff --git a/koans/about_arrays.rb b/koans/about_arrays.rb index 2ed3181..9f27b5a 100644 --- a/koans/about_arrays.rb +++ b/koans/about_arrays.rb @@ -45,9 +45,9 @@ class AboutArrays < EdgeCase::Koan end def test_arrays_and_ranges - assert_equal Range, (1..5).class + assert_equal __, (1..5).class assert_not_equal [1,2,3,4,5], (1..5) - assert_equal [1,2,3,4,5], (1..5).to_a + assert_equal __, (1..5).to_a assert_equal __, (1...5).to_a end diff --git a/koans/about_classes.rb b/koans/about_classes.rb index 08858b8..fce0be0 100644 --- a/koans/about_classes.rb +++ b/koans/about_classes.rb @@ -130,7 +130,7 @@ class AboutClasses < EdgeCase::Koan fido = Dog6.new("Fido") rover = Dog6.new("Rover") - assert_not_equal rover.name, fido.name + assert_equal __, rover.name != fido.name end # ------------------------------------------------------------------ @@ -164,12 +164,12 @@ class AboutClasses < EdgeCase::Koan def test_to_s_provides_a_string_version_of_the_object fido = Dog7.new("Fido") - assert_equal "Fido", fido.to_s + assert_equal __, fido.to_s end def test_to_s_is_used_in_string_interpolation fido = Dog7.new("Fido") - assert_equal "My dog is Fido", "My dog is #{fido}" + assert_equal __, "My dog is #{fido}" end def test_inspect_provides_a_more_complete_string_version diff --git a/koans/about_exceptions.rb b/koans/about_exceptions.rb index c44833e..32708b6 100644 --- a/koans/about_exceptions.rb +++ b/koans/about_exceptions.rb @@ -22,12 +22,12 @@ class AboutExceptions < EdgeCase::Koan assert_equal __, result - assert ex.is_a?(StandardError), "Failure message." - assert ex.is_a?(RuntimeError), "Failure message." + assert ex.is_a?(___), "Failure message." + assert ex.is_a?(___), "Failure message." assert RuntimeError.ancestors.include?(StandardError), "RuntimeError is a subclass of StandardError" - + assert_equal __, ex.message end diff --git a/koans/about_hashes.rb b/koans/about_hashes.rb index d491f6d..3e4e62c 100644 --- a/koans/about_hashes.rb +++ b/koans/about_hashes.rb @@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/edgecase') class AboutHashes < EdgeCase::Koan def test_creating_hashes empty_hash = Hash.new - assert_equal Hash, empty_hash.class + assert_equal __, empty_hash.class assert_equal({}, empty_hash) assert_equal __, empty_hash.size end @@ -25,7 +25,7 @@ class AboutHashes < EdgeCase::Koan hash[:one] = "eins" expected = { :one => __, :two => "dos" } - assert_equal expected, hash + assert_equal __, expected == hash # Bonus Question: Why was "expected" broken out into a variable # rather than used as a literal? @@ -35,7 +35,7 @@ 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 @@ -43,7 +43,7 @@ class AboutHashes < EdgeCase::Koan assert_equal __, hash.keys.size assert_equal __, hash.keys.include?(:one) assert_equal __, hash.keys.include?(:two) - assert_equal Array, hash.keys.class + assert_equal __, hash.keys.class end def test_hash_values @@ -51,16 +51,16 @@ class AboutHashes < EdgeCase::Koan assert_equal __, hash.values.size assert_equal __, hash.values.include?("uno") assert_equal __, hash.values.include?("dos") - assert_equal Array, hash.values.class + assert_equal __, hash.values.class end def test_combining_hashes hash = { "jim" => 53, "amy" => 20, "dan" => 23 } new_hash = hash.merge({ "jim" => 54, "jenny" => 26 }) - assert_not_equal hash, new_hash - + assert_equal __, hash != new_hash + expected = { "jim" => __, "amy" => 20, "dan" => 23, "jenny" => __ } - assert_equal expected, new_hash + assert_equal __, expected == new_hash end end diff --git a/koans/about_iteration.rb b/koans/about_iteration.rb index 1b64cbe..591b869 100644 --- a/koans/about_iteration.rb +++ b/koans/about_iteration.rb @@ -12,7 +12,7 @@ class AboutIteration < EdgeCase::Koan array.each do |item| sum += item end - assert_equal 6, sum + assert_equal __, sum end def test_each_can_use_curly_brace_blocks_too diff --git a/koans/about_java_interop.rb b/koans/about_java_interop.rb new file mode 100644 index 0000000..0bdd183 --- /dev/null +++ b/koans/about_java_interop.rb @@ -0,0 +1,98 @@ +require File.expand_path(File.dirname(__FILE__) + '/edgecase') + +include Java + +# Concepts +# * Pull in a java class +# * calling a method, Camel vs snake +# * Resovling module/class name conflicts +# * Showing what gets returned +# * Ruby Strings VS Java Strings +# * Calling custom java class +# * Calling Ruby from java??? + +class AboutJavaInterop < EdgeCase::Koan + def test_using_a_java_library_class + java_array = java.util.ArrayList.new + assert_equal __, java_array.class + end + + def test_java_class_can_be_referenced_using_both_ruby_and_java_like_syntax + assert_equal __, Java::JavaUtil::ArrayList == java.util.ArrayList + end + + def test_include_class_includes_class_in_module_scope + assert_nil defined?(TreeSet) + include_class "java.util.TreeSet" + assert_equal __, defined?(TreeSet) + end + + # THINK ABOUT IT: + # + # What if we use: + # + # include_class "java.lang.String" + # + # What would be the value of the String constant after this + # include_class is run? Would it be useful to provide a way of + # aliasing java classes to different names? + + JString = java.lang.String + def test_also_java_class_can_be_given_ruby_aliases + java_string = JString.new("A Java String") + assert_equal __, java_string.class + assert_equal __, JString + end + + def test_can_directly_call_java_methods_on_java_objects + java_string = JString.new("A Java String") + assert_equal __, java_string.toLowerCase + end + + def test_jruby_provides_snake_case_versions_of_java_methods + java_string = JString.new("A Java String") + assert_equal __, java_string.to_lower_case + end + + def test_jruby_provides_question_mark_versions_of_boolean_methods + java_string = JString.new("A Java String") + assert_equal __, java_string.endsWith("String") + assert_equal __, java_string.ends_with("String") + assert_equal __, java_string.ends_with?("String") + end + + def test_java_string_are_not_ruby_strings + ruby_string = "A Java String" + java_string = java.lang.String.new(ruby_string) + assert_equal __, java_string.is_a?(java.lang.String) + assert_equal __, java_string.is_a?(String) + end + + def test_java_strings_can_be_compared_to_ruby_strings_maybe + ruby_string = "A Java String" + java_string = java.lang.String.new(ruby_string) + assert_equal __, ruby_string == java_string + assert_equal __, java_string == ruby_string + + # THINK ABOUT IT: + # + # Is there any possible way for this to be more wrong? + # + # SERIOUSLY, THINK ABOUT IT: + # + # Why do you suppose that Ruby and Java strings compare like that? + # + # ADVANCED THINK ABOUT IT: + # + # Is there a way to make Ruby/Java string comparisons commutative? + # How would you do it? + end + + def test_however_most_methods_returning_strings_return_ruby_strings + java_array = java.util.ArrayList.new + assert_equal __, java_array.toString + assert_equal __, java_array.toString.is_a?(String) + assert_equal __, java_array.toString.is_a?(java.lang.String) + end + +end diff --git a/koans/about_modules.rb b/koans/about_modules.rb index c528c32..cd967a9 100644 --- a/koans/about_modules.rb +++ b/koans/about_modules.rb @@ -45,7 +45,7 @@ class AboutModules < EdgeCase::Koan def test_module_methods_are_also_availble_in_the_object fido = Dog.new assert_nothing_raised(Exception) do - fido.set_name("Rover") + fido.set_name("Rover") end end diff --git a/koans/about_regular_expressions.rb b/koans/about_regular_expressions.rb index c35d757..8344911 100644 --- a/koans/about_regular_expressions.rb +++ b/koans/about_regular_expressions.rb @@ -3,11 +3,11 @@ require File.expand_path(File.dirname(__FILE__) + '/edgecase') class AboutRegularExpressions < EdgeCase::Koan def test_a_pattern_is_a_regular_expression - assert_equal Regexp, /pattern/.class + assert_equal __, /pattern/.class end def test_a_regexp_can_search_a_string_for_matching_content - assert_equal "match", "some matching content"[/match/] + assert_equal __, "some matching content"[/match/] end def test_a_failed_match_returns_nil diff --git a/koans/about_scope.rb b/koans/about_scope.rb index edbe876..d07d2af 100644 --- a/koans/about_scope.rb +++ b/koans/about_scope.rb @@ -29,8 +29,8 @@ class AboutScope < EdgeCase::Koan assert_equal __, fido.identify assert_equal __, rover.identify - assert_not_equal fido.class, rover.class - assert_not_equal Jims::Dog, Joes::Dog + assert_equal __, fido.class != rover.class + assert_equal __, Jims::Dog != Joes::Dog end # ------------------------------------------------------------------ diff --git a/koans/edgecase.rb b/koans/edgecase.rb index 1a5b882..658da2e 100644 --- a/koans/edgecase.rb +++ b/koans/edgecase.rb @@ -3,6 +3,10 @@ require 'test/unit/assertions' +# -------------------------------------------------------------------- +# Support code for the Ruby Koans. +# -------------------------------------------------------------------- + class FillMeInError < StandardError end @@ -16,6 +20,8 @@ def in_ruby_version(*versions) yield if versions.any? { |v| ruby_version?(v) } end +# Standard, generic replacement value. +# If value19 is given, it is used inplace of value for Ruby 1.9. def __(value="FILL ME IN", value19=:mu) if RUBY_VERSION < "1.9" value @@ -24,6 +30,7 @@ def __(value="FILL ME IN", value19=:mu) end end +# Numeric replacement value. def _n_(value=999999, value19=:mu) if RUBY_VERSION < "1.9" value @@ -32,10 +39,12 @@ def _n_(value=999999, value19=:mu) end end +# Error object replacement value. def ___(value=FillMeInError) value end +# Method name replacement. class Object def ____(method=nil) if method @@ -48,7 +57,25 @@ class Object end end +class String + def side_padding(width) + extra = width - self.size + if width < 0 + self + else + left_padding = extra / 2 + right_padding = (extra+1)/2 + (" " * left_padding) + self + (" " *right_padding) + end + end +end + module EdgeCase + class << self + def simple_output + ENV['SIMPLE_KOAN_OUTPUT'] == 'true' + end + end module Color #shamelessly stolen (and modified) from redgreen @@ -176,6 +203,21 @@ module EdgeCase end def end_screen + if EdgeCase.simple_output + boring_end_screen + else + artistic_end_screen + end + end + + def boring_end_screen + puts "Mountains are again merely mountains" + end + + def artistic_end_screen + "JRuby 1.9.x Koans" + ruby_version = "(in #{'J' if defined?(JRUBY_VERSION)}Ruby #{defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION})" + ruby_version = ruby_version.side_padding(54) completed = <<-ENDTEXT ,, , ,, : ::::, :::, @@ -192,8 +234,8 @@ module EdgeCase ,:::::::::::, ::::::::::::, :::::::::::, ,:::::::::::: ::::::::::::: ,:::::::::::: -:::::::::::: Ruby Koans ::::::::::::, -:::::::::::: ,::::::::::::, +:::::::::::: Ruby Koans ::::::::::::, +::::::::::::#{ ruby_version },::::::::::::, :::::::::::, , :::::::::::: ,:::::::::::::, brought to you by ,,::::::::::::, :::::::::::::: ,:::::::::::: @@ -260,7 +302,7 @@ ENDTEXT def find_interesting_lines(backtrace) backtrace.reject { |line| - line =~ /test\/unit\/|edgecase\.rb/ + line =~ /test\/unit\/|edgecase\.rb|minitest/ } end