rubybreaker 0.0.3 → 0.0.4

data/lib/rubybreaker.rb

@@ -30,9 +30,6 @@ module RubyBreaker
   # monitor.
   INSTALLED = []
   
-  # This array lists monitored modules/classes that are outputed.
-  DOCUMENTED = []
-
   # Extension used by RubyBreaker for output/input
   EXTENSION = "rubybreaker"
 
@@ -75,71 +72,6 @@ module RubyBreaker
       eval "load \"#{OPTIONS[:io_file]}\"", TOPLEVEL_BINDING
     end
 
-    # Pretty prints type information for methods
-    def self.pp_methods(pp, meth_type_map)
-      meth_type_map.each { |meth_name, meth_type|
-        case meth_type
-        when MethodType
-          pp.breakable()
-          pp.text("typesig(\"")
-          TypeUnparser.unparse_pp(pp,meth_type)
-          pp.text("\")")
-        when MethodListType
-          meth_type.types.each { |real_meth_type|
-            pp.breakable()
-            pp.text("typesig(\"")
-            TypeUnparser.unparse_pp(pp,real_meth_type)
-            pp.text("\")")
-          }
-        else
-          # Can't happen
-        end
-      }
-    end
-
-    # Pretty prints type information for the module/class
-    def self.pp_module(pp, mod)
-      # Skip it if we already have seen it
-      return if DOCUMENTED.include?(mod) || mod.to_s[0..1] == "#<"
-
-      # Remember that we have documented this module/class
-      DOCUMENTED << mod  
-
-      # Get the method type mapping
-      meth_type_map = Inspector.inspect_all(mod)
-
-      # Check if this module is a class
-      keyword = mod.instance_of?(Class) ? "class" : "module"
-      
-      pp.text("#{keyword} #{mod.to_s}", 80)
-      pp.nest(2) do 
-        pp.breakable("")
-        pp.text("include RubyBreaker::Broken", 80)
-
-        # See if there is any class method to show
-        eigen = Runtime.eigen_class(mod)
-
-        if !DOCUMENTED.include?(eigen)
-          DOCUMENTED << eigen
-          eigen_meth_type_map = Inspector.inspect_all(eigen)
-          if eigen_meth_type_map.size > 0 
-            pp.breakable()
-            pp.text("class << self", 80)
-            pp.nest(2) do
-              self.pp_methods(pp, eigen_meth_type_map)
-            end
-            pp.breakable()
-            pp.text("end", 80)
-          end
-        end
-        self.pp_methods(pp, meth_type_map)
-
-      end
-      pp.breakable() 
-      pp.text("end",80)
-      pp.breakable()
-    end
-
     # This method will generate the output.
     def self.output()
 
@@ -147,15 +79,15 @@ module RubyBreaker
 
       io_exist = OPTIONS[:io_file] && File.exist?(OPTIONS[:io_file])
 
-      str = ""
-      pp = PrettyPrint.new(str)
-
+      code = ""
       # Document each module that was monitored
-      INSTALLED.each { |mod| self.pp_module(pp, mod) }
-      pp.flush
-
-      # First, display the result on the stdout if set
-      print str if OPTIONS[:stdout]
+      INSTALLED.each { |mod| 
+        str = Runtime::TypesigUnparser.unparse(mod) 
+        code << str
+        if OPTIONS[:mode] == :lib
+          print str
+        end
+      }
 
       # If this was a library mode run, exit now. 
       return if OPTIONS[:mode] == :lib
@@ -166,7 +98,7 @@ module RubyBreaker
           f.puts "# This file is auto-generated by RubyBreaker"
           f.puts "require \"rubybreaker\""
         end
-        f.puts str
+        f.print code
       end
 
       RubyBreaker.verbose("Done generating type documentation")

data/test/integrated/tc_namespace.rb

@@ -0,0 +1,56 @@
+require "test/unit"
+require_relative "../../lib/rubybreaker"
+
+class IntegratedNamespaceTest < Test::Unit::TestCase
+  include RubyBreaker
+  include RubyBreaker::TestCase
+
+  class A < String
+    class C < String
+      class D < String
+        class E < String
+        end
+      end
+      class F
+      end
+    end
+  end
+
+  class B
+    include RubyBreaker::Breakable
+    def foo(x); x.to_s end
+    def bar(x); x.to_s end
+    def baz(x); x.to_s end
+  end
+
+  def test_namspace_b_foo
+    a = A.new
+    b = B.new
+    b.foo(a)
+    meth_type = Runtime::Inspector.inspect_meth(B, :foo)
+    str = RubyBreaker::TypeUnparser.unparse(meth_type)
+    # puts str
+    assert_equal("foo(integrated_namespace_test/a[to_s]) -> string", str, "B#foo failed.")
+  end
+  
+  def test_namspace_b_foo_nested
+    a = A::C.new
+    b = B.new
+    b.bar(a)
+    meth_type = Runtime::Inspector.inspect_meth(B, :bar)
+    str = RubyBreaker::TypeUnparser.unparse(meth_type)
+    # puts str
+    assert_equal("bar(integrated_namespace_test/a/c[to_s]) -> string", str, "B#bar failed.")
+  end
+  
+  def test_namespace_e_baz
+    e = A::C::D::E.new
+    b = B.new
+    b.baz(e)
+    meth_type = Runtime::Inspector.inspect_meth(B, :baz)
+    str = meth_type.unparse(:namespace => A::C::F)
+    assert_equal("baz(d/e[to_s]) -> string", str, "B#baz failed.")
+  end
+  
+end
+

data/test/ts_integrated.rb

@@ -5,3 +5,4 @@ require_relative "integrated/tc_simple1"
 require_relative "integrated/tc_inherit_broken"
 require_relative "integrated/tc_class_methods"
 require_relative "integrated/tc_both_broken_breakable"
+require_relative "integrated/tc_namespace"

data/test/ts_rspec.rb

@@ -0,0 +1,31 @@
+require "rspec"
+require_relative "../lib/rubybreaker"
+
+class RSpecTestA
+  include RubyBreaker::Breakable
+  def foo(x); x.to_s end
+end
+
+class RSpecTestB
+  include RubyBreaker::Broken
+  typesig("foo(fixnum[to_s]) -> string")
+end
+
+describe RSpecTestA do
+  it "should return a string of number" do
+    a = RSpecTestA.new
+    a.foo(1)
+    a_foo_type = RubyBreaker::Runtime::Inspector.inspect_meth(RSpecTestA, :foo)
+    str = a_foo_type.unparse()
+    str.should == "foo(fixnum[to_s]) -> string"
+  end
+end
+
+describe RSpecTestB do
+  it "should return the documented type of B#foo" do
+    b_foo_type = RubyBreaker::Runtime::Inspector.inspect_meth(RSpecTestB, :foo)
+    str = b_foo_type.unparse()
+    str.should == "foo(fixnum[to_s]) -> string"
+  end
+end
+

data/test/ts_type.rb

@@ -3,3 +3,5 @@ require "test/unit"
 require_relative "type/tc_comparer"
 require_relative "type/tc_parser"
 require_relative "type/tc_unparser"
+require_relative "type/tc_camelize"
+require_relative "type/tc_namespace"

data/test/type/tc_camelize.rb

@@ -0,0 +1,24 @@
+# This test verifies type unparser for RubyBreaker types.
+require "test/unit"
+require_relative "../../lib/rubybreaker/type"
+
+class UnparserCamelizeTest < Test::Unit::TestCase
+
+  include RubyBreaker
+  
+  class CamelizedClassName; end
+
+  def test_camelize_type()
+    t1 = NominalType.new(CamelizedClassName)
+    str1 = t1.unparse({:style => :camelize, :namespace => UnparserCamelizeTest})
+    # puts str1
+    assert_equal("CamelizedClassName",str1.strip())
+  end
+
+  def test_camelize_no_namespace_type()
+    t1 = NominalType.new(CamelizedClassName)
+    str1 = t1.unparse({:style => :camelize, :namespace => UnparserCamelizeTest})
+    # puts str1
+    assert_equal("CamelizedClassName",str1.strip())
+  end
+end

data/test/type/tc_namespace.rb

@@ -0,0 +1,25 @@
+# This test verifies handling of namespace in parsing types.
+require "test/unit"
+require_relative "../../lib/rubybreaker/type"
+
+class TypeNamespaceTest < Test::Unit::TestCase
+
+  include RubyBreaker
+
+  class A
+  end
+
+  def setup
+    @parser = Runtime::TypeSigParser::PARSER
+  end
+  
+  def teardown
+  end
+
+  def test_namespace_1
+    t1 = @parser.parse("foo(type_namespace_test/a[to_s]) -> string").value
+    str = t1.unparse(:style => :camelize)
+    assert_equal("foo(TypeNamespaceTest::A[to_s]) -> String", str)
+  end
+  
+end

data/test/type/tc_unparser.rb

@@ -1,8 +1,7 @@
 # This test verifies type unparser for RubyBreaker types.
 
-dir = File.dirname(__FILE__)
 require "test/unit"
-require "#{dir}/../../lib/rubybreaker/type"
+require_relative "../../lib/rubybreaker/type"
 
 class UnparserTest < Test::Unit::TestCase
 
@@ -30,14 +29,14 @@ class UnparserTest < Test::Unit::TestCase
 
   def test_nominal_type()
     t1 = NominalType.new(A)
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     # puts str1
     assert_equal("a",str1)
   end
 
   def test_self_type()
     t1 = SelfType.new()
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     # puts str1
     assert_equal("self", str1)
   end
@@ -45,7 +44,7 @@ class UnparserTest < Test::Unit::TestCase
   def test_opt_type()
     t1 = NominalType.new(A)
     t2 = OptionalType.new(t1)
-    str2 = TypeUnparser.unparse(t2)
+    str2 = TypeUnparser.unparse(t2, :namespace => UnparserTest)
     # puts str1
     assert_equal("a?",str2)
   end
@@ -55,7 +54,7 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = OrType.new([t1, t2])
     t4 = OptionalType.new(t3)
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str1
     assert_equal("(a || b)?",str4)
   end
@@ -63,15 +62,15 @@ class UnparserTest < Test::Unit::TestCase
   def test_star_type()
     t1 = NominalType.new(A)
     t2 = VarLengthType.new(t1)
-    str2 = TypeUnparser.unparse(t2)
+    str2 = TypeUnparser.unparse(t2, :namespace => UnparserTest)
     # puts str1
-    assert_equal("a*",str2)
+    assert_equal("a*", str2)
   end
 
   def test_star_duck_type()
     t1 = DuckType.new([:foo, :bar])
     t2 = VarLengthType.new(t1)
-    str2 = TypeUnparser.unparse(t2)
+    str2 = TypeUnparser.unparse(t2, :namespace => UnparserTest)
     # puts str1
     assert_equal("[bar, foo]*",str2)
   end
@@ -79,7 +78,7 @@ class UnparserTest < Test::Unit::TestCase
   def test_star_fusion_type()
     t1 = FusionType.new(NominalType.new(A), [:foo, :bar])
     t2 = VarLengthType.new(t1)
-    str2 = TypeUnparser.unparse(t2)
+    str2 = TypeUnparser.unparse(t2, :namespace => UnparserTest)
     # puts str1
     assert_equal("a[bar, foo]*",str2)
   end
@@ -89,49 +88,49 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = OrType.new([t1, t2])
     t4 = VarLengthType.new(t3)
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str1
     assert_equal("(a || b)*",str4)
   end
 
   def test_duck_type()
     t1 = DuckType.new(["+"])
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     # puts str1
     assert_equal("[+]",str1)
   end
   
   def test_duck_type_more_meths()
     t1 = DuckType.new(["+","foo","bar"])
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     #puts str1
     assert_equal("[+, bar, foo]",str1)
   end
 
   def test_duck_type_symbolic_meths()
     t1 = DuckType.new(["+","-","[]","[]="])
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     #puts str1
     assert_equal("[+, -, [], []=]",str1)
   end
 
   def test_fusion_type()
     t1 = FusionType.new(NominalType.new(A), ["+"])
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     # puts str1
     assert_equal("a[+]",str1)
   end
 
   def test_fusion_type_more_meths()
     t1 = FusionType.new(NominalType.new(A), ["+","foo","bar"])
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     # puts str1
     assert_equal("a[+, bar, foo]",str1)
   end
   
   def test_fusion_type_symbolic_meths()
     t1 = FusionType.new(NominalType.new(A), ["+","-","[]","[]="])
-    str1 = TypeUnparser.unparse(t1)
+    str1 = TypeUnparser.unparse(t1, :namespace => UnparserTest)
     # puts str1
     assert_equal("a[+, -, [], []=]",str1)
   end
@@ -140,7 +139,7 @@ class UnparserTest < Test::Unit::TestCase
     t1 = NominalType.new(A)
     t2 = NominalType.new(B)
     t3 = OrType.new([t1,t2])
-    str3 = TypeUnparser.unparse(t3)
+    str3 = TypeUnparser.unparse(t3, :namespace => UnparserTest)
     # puts str3
     assert_equal("a || b", str3)
   end
@@ -150,7 +149,7 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = NominalType.new(C)
     t4 = OrType.new([t1,t2,t3])
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str3
     assert_equal("a || b || c", str4)
   end
@@ -159,7 +158,7 @@ class UnparserTest < Test::Unit::TestCase
     t1 = NominalType.new(A)
     t2 = NominalType.new(B)
     t3 = BlockType.new([t1],nil,t2)
-    str3 = TypeUnparser.unparse(t3)
+    str3 = TypeUnparser.unparse(t3, :namespace => UnparserTest)
     # puts str3
     assert_equal("|a| -> b",str3)
   end
@@ -169,7 +168,7 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = NominalType.new(C)
     t4 = BlockType.new([t1,t2],nil,t3)
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str3
     assert_equal("|a, b| -> c",str4)
   end
@@ -179,7 +178,7 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = SelfType.new()
     t4 = BlockType.new([t1,t2],nil,t3)
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str3
     assert_equal("|a, b| -> self",str4)
   end
@@ -190,7 +189,7 @@ class UnparserTest < Test::Unit::TestCase
     t3 = NominalType.new(C)
     t4 = NominalType.new(D)
     t5 = BlockType.new([t1],BlockType.new([t2],nil,t3),t4)
-    str5 = TypeUnparser.unparse(t5)
+    str5 = TypeUnparser.unparse(t5, :namespace => UnparserTest)
     # puts str5
     assert_equal("|a| {|b| -> c} -> d",str5)
   end
@@ -202,7 +201,7 @@ class UnparserTest < Test::Unit::TestCase
     t4 = NominalType.new(D)
     t5 = NominalType.new(E)
     t6 = BlockType.new([t1,t2],BlockType.new([t3],nil,t4),t5)
-    str6 = TypeUnparser.unparse(t6)
+    str6 = TypeUnparser.unparse(t6, :namespace => UnparserTest)
     # puts str5
     assert_equal("|a, b| {|c| -> d} -> e",str6)
   end 
@@ -214,7 +213,7 @@ class UnparserTest < Test::Unit::TestCase
     t4 = NominalType.new(D)
     t5 = NominalType.new(E)
     t6 = BlockType.new([OrType.new([t1,t2])],BlockType.new([t3],nil,t4),t5)
-    str6 = TypeUnparser.unparse(t6)
+    str6 = TypeUnparser.unparse(t6, :namespace => UnparserTest)
     # puts str5
     assert_equal("|a || b| {|c| -> d} -> e",str6)
   end
@@ -223,7 +222,7 @@ class UnparserTest < Test::Unit::TestCase
     t1 = NominalType.new(A)
     t2 = NominalType.new(B)
     t3 = MethodType.new("m",[t1],nil,t2)
-    str3 = TypeUnparser.unparse(t3)
+    str3 = TypeUnparser.unparse(t3, :namespace => UnparserTest)
     # puts str3
     assert_equal("m(a) -> b", str3)
   end
@@ -232,7 +231,7 @@ class UnparserTest < Test::Unit::TestCase
     t1 = NominalType.new(A)
     t2 = NominalType.new(B)
     t3 = MethodType.new("==",[t1],nil,t2)
-    str3 = TypeUnparser.unparse(t3)
+    str3 = TypeUnparser.unparse(t3, :namespace => UnparserTest)
     # puts str3
     assert_equal("==(a) -> b", str3)
   end
@@ -242,7 +241,7 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = NominalType.new(C)
     t4 = MethodType.new("m",[t1,t2],nil,t3)
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str3
     assert_equal("m(a, b) -> c", str4)
   end
@@ -252,7 +251,7 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = SelfType.new()
     t4 = MethodType.new("m",[t1,t2],nil,t3)
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str3
     assert_equal("m(a, b) -> self", str4)
   end
@@ -262,7 +261,7 @@ class UnparserTest < Test::Unit::TestCase
     t2 = NominalType.new(B)
     t3 = NominalType.new(C)
     t4 = MethodType.new("m",[OrType.new([t1,t2])],nil,t3)
-    str4 = TypeUnparser.unparse(t4)
+    str4 = TypeUnparser.unparse(t4, :namespace => UnparserTest)
     # puts str3
     assert_equal("m(a || b) -> c", str4)
   end
@@ -273,7 +272,7 @@ class UnparserTest < Test::Unit::TestCase
     t3 = NominalType.new(C)
     t4 = NominalType.new(D)
     t5 = MethodType.new("m",[t1],BlockType.new([t2],nil,t3),t4)
-    str5 = TypeUnparser.unparse(t5)
+    str5 = TypeUnparser.unparse(t5, :namespace => UnparserTest)
     # puts str5
     assert_equal("m(a) {|b| -> c} -> d", str5)
   end
@@ -285,7 +284,7 @@ class UnparserTest < Test::Unit::TestCase
     t4 = NominalType.new(D)
     t5 = NominalType.new(E)
     t6 = MethodType.new("m",[t1,t2],BlockType.new([t3],nil,t4),t5)
-    str6 = TypeUnparser.unparse(t6)
+    str6 = TypeUnparser.unparse(t6, :namespace => UnparserTest)
     # puts str5
     assert_equal("m(a, b) {|c| -> d} -> e", str6)
   end

data/webpage/index.html

@@ -16,7 +16,7 @@
 
 <h1>Introduction</h1>
 
-<p>RubyBreaker is a dynamic type documentation tool written purely in Ruby. It
+<p>RubyBreaker is a dynamic type documentation tool written in pure Ruby. It
 provides the framework for dynamically instrumenting a Ruby program to
 monitor objects during executions and document the observed type
 information. The type documentation generated by RubyBreaker is also an
@@ -27,7 +27,7 @@ program.</p>
 <p>The primary goal of RubyBreaker is to assign a type signature to every
 method in designated modules and classes.  A type signature is written in
 the RubyBreaker Type Annotation Language which resembles the documentation
-style used in RubyDoc. Overall, this tool should help Ruby programmers
+style used in Ruby API Doc. Overall, this tool should help Ruby programmers
 document their code more rigorously and effectively.  Currently, manual
 modification of the user program is required to run RubyBreaker, but this is
 kept minimal.</p>
@@ -40,10 +40,9 @@ be found in <a href="rdoc/index.html">here</a>.</p>
 <h2>Limitations</h2>
 
 <ul>
-<li>It only works on toy Ruby programs so far :)</li>
 <li>Block argument cannot be auto-documented. (Inherent)</li>
 <li>Manual modification (minimal) of code is required.</li>
-<li>No parametric polymorphic types are supported.</li>
+<li>Parametric polymorphic types are not supported.</li>
 </ul>
 
 
@@ -153,7 +152,8 @@ necessary to obtain precise type information.</p>
 First, the user must indicate which modules are subject to analysis and
 which modules can be used for the analysis. Next, the user has to indicate
 where the entry point of the program is. Alternatively, he has to make a
-small change to the test cases to use RubyBreaker's testing framework.</p>
+small change to the test cases to use RubyBreaker's testing framework. (If
+you are using RSpec, there is no need for this change.)</p>
 
 <h3>Breakable and Broken</h3>
 
@@ -236,9 +236,7 @@ end
 <p>In Ruby, as soon as a file is <code>require</code>d, the execution of that file begins.
 For RubyBreaker, however, it is not trivial to find the actual starting
 point of the program because there <em>has</em> to be a clear point in time at
-which monitoring of <code>Breakable</code> modules begins. <em>This is necessary as
-attempting to instrument and monitor at the same time will cause an infinite
-loop!</em></p>
+which monitoring of <code>Breakable</code> modules begins.</p>
 
 <p>Indicating the program entry point is simply done by inserting the following
 line at the code (assuming "<code>require 'rubybreaker'</code>" is already placed at
@@ -254,11 +252,11 @@ run the instrumented code (for <code>Breakable</code> modules) which will gather
 information for methods.</p>
 
 <p>Although this seems simple and easy, this is not the recommended way for
-analyzing a program. Why? Because RubyBreaker has a built-in testing
-framework that (supposedly :)) works seemlessly with the existing tests of
-the program.</p>
+analyzing a program. Why? Because RubyBreaker comes with a replacement for
+the built-in testing framework for Ruby. Even better, if you are using
+RSpec, there is no need to change any test code.</p>
 
-<h3>Using RubyBreaker Testing Framework</h3>
+<h3>Using the Built-in Testing Framework</h3>
 
 <p>Instead of manually inserting the entry point indicator into the program,
 the user can take advantage of the Ruby Unit Test framework. This is the
@@ -274,11 +272,28 @@ class TestClassA &lt; Test::Unit::TestCase
 end
 </code></pre>
 
-<p>That's it!</p>
+<p>That's it! Also, remember that classes and modules can be re-opened for
+"patches" in Ruby. This means that the original classes or modules do not
+need to be modified to include <code>Broken</code> and/or <code>Breakable</code>. In each test
+suite or test case, those classes and modules can be re-opened to include
+<code>Broken</code> and/or <code>Breakable</code>. The following shows an example of such a test
+case.</p>
 
-<p>Currently, RubyBreaker only supports the standard unit test framework.
-Other testing frameworks such as RSpec and Cucumber are not supported at the
-moment (but will be in future/hopefully).</p>
+<pre><code>require "rubybreaker"
+require "test/unit"
+class A
+  include RubyBreaker::Breakable
+end
+class TestClassA &lt; Test::Unit::TestCase
+   ...
+end
+</code></pre>
+
+<h3>Using RSpec</h3>
+
+<p>If using RSpec, it is even easier! No changes are needed for the test code.
+Really! <em>Well, it is still necessary to <code>require rubybreaker</code> and manually
+insert <code>Breakable</code> and <code>Broken</code> to appropriate classes and modules.</em></p>
 
 <h2>Type Annotation</h2>
 
@@ -316,7 +331,9 @@ instance, <code>fixnum</code> is an object of type <code>Fixnum</code>. Use lowe
 underscores instead of <em>camelized</em> name. <code>MyClass</code>, for example would be
 <code>my_class</code> in RubyBreaker type signatures. There is no particular
 reason for this convention other than it is the common practice used in
-RubyDoc.</p>
+RubyDoc. Use <code>/</code> to indicate the namespace delimiter <code>::</code>. For example,
+<code>NamspaceA::ClassB</code> would be represented by <code>namespace_a/class_b</code> in
+a RubyBreaker type signature.</p>
 
 <h3>Self Type</h3>
 
@@ -475,8 +492,6 @@ RubyBreaker. <em>Technical documentation coming soon...</em></p>
 University of Maryland and represents an object using a structural type with
 respect to a nominal type.</p>
 
-<hr />
-
 <h1>Copyright</h1>
 
 <p>Copyright (c) 2012 Jong-hoon (David) An. All Rights Reserved.</p>