rubybreaker 0.0.1 → 0.0.2

data/test/type/tc_comparer.rb

@@ -63,13 +63,13 @@ class ComparerTest < Test::Unit::TestCase
     assert(!t7.eql?(t11), msg(t7, t11, true))
   end
 
-	def test_self
-		t1 = SelfType.new()
-		t2 = SelfType.new()
-		t3 = NominalType.new(Fixnum)
-		assert(t1.eql?(t2), msg(t1, t2))
-		assert(!t1.eql?(t3), msg(t1, t3, true))
-	end
+  def test_self
+    t1 = SelfType.new()
+    t2 = SelfType.new()
+    t3 = NominalType.new(Fixnum)
+    assert(t1.eql?(t2), msg(t1, t2))
+    assert(!t1.eql?(t3), msg(t1, t3, true))
+  end
 
   def test_duck
     t1 = DuckType.new([:foo, :bar])
@@ -84,45 +84,45 @@ class ComparerTest < Test::Unit::TestCase
   def test_fusion
     t1 = FusionType.new(NominalType.new(Fixnum), [:to_s, :to_f])
     t2 = FusionType.new(NominalType.new(Fixnum), [:to_f, :to_s])
-		t3 = FusionType.new(NominalType.new(String), [:to_s, :to_f])
-		t4 = DuckType.new([:to_s, :to_f])
-		t5 = NominalType.new(Fixnum)
-		assert(t1.eql?(t2), msg(t1, t2))
-		assert(!t1.eql?(t3), msg(t1, t3, true))
-		assert(!t1.eql?(t4), msg(t1, t4, true))
-		assert(!t1.eql?(t5), msg(t1, t5, true))
+    t3 = FusionType.new(NominalType.new(String), [:to_s, :to_f])
+    t4 = DuckType.new([:to_s, :to_f])
+    t5 = NominalType.new(Fixnum)
+    assert(t1.eql?(t2), msg(t1, t2))
+    assert(!t1.eql?(t3), msg(t1, t3, true))
+    assert(!t1.eql?(t4), msg(t1, t4, true))
+    assert(!t1.eql?(t5), msg(t1, t5, true))
   end
 
-	def test_block_no_arg
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = BlockType.new([],nil,t1) 
-		t5 = BlockType.new([],nil,t2)
-		t6 = BlockType.new([],nil,t3)
-		assert(t4.eql?(t5), msg(t4, t5))
-		assert(!t4.eql?(t6), msg(t4, t6, true))
-	end
+  def test_block_no_arg
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = BlockType.new([],nil,t1) 
+    t5 = BlockType.new([],nil,t2)
+    t6 = BlockType.new([],nil,t3)
+    assert(t4.eql?(t5), msg(t4, t5))
+    assert(!t4.eql?(t6), msg(t4, t6, true))
+  end
   
-	def test_block_one_arg
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = BlockType.new([t1],nil,t3) 
-		t5 = BlockType.new([t2],nil,t3)
-		t6 = BlockType.new([],nil,t3)
-		assert(t4.eql?(t5), msg(t4, t5))
-		assert(!t4.eql?(t6), msg(t4, t6, true))
-	end
-
-	def test_block_more_args
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = OptionalType.new(NominalType.new(Object))
-		t5 = VarLengthType.new(NominalType.new(String))
-		t6 = NominalType.new(BasicObject)
-		t7 = BlockType.new([t1,t4,t5],nil,t3)
+  def test_block_one_arg
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = BlockType.new([t1],nil,t3) 
+    t5 = BlockType.new([t2],nil,t3)
+    t6 = BlockType.new([],nil,t3)
+    assert(t4.eql?(t5), msg(t4, t5))
+    assert(!t4.eql?(t6), msg(t4, t6, true))
+  end
+
+  def test_block_more_args
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = OptionalType.new(NominalType.new(Object))
+    t5 = VarLengthType.new(NominalType.new(String))
+    t6 = NominalType.new(BasicObject)
+    t7 = BlockType.new([t1,t4,t5],nil,t3)
     t8 = BlockType.new([t2,t4,t5],nil,t3)
     t9 = BlockType.new([t1,t5,t4],nil,t3)
     t10 = BlockType.new([t1,t4],nil,t3)
@@ -133,56 +133,56 @@ class ComparerTest < Test::Unit::TestCase
     assert(!t7.eql?(t10), msg(t7, t10, true))
     assert(!t7.eql?(t11), msg(t7, t11, true))
     assert(!t7.eql?(t12), msg(t7, t12, true))
-	end
-
-	def test_method_no_arg
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = MethodType.new(:foo,[],nil,t1) 
-		t5 = MethodType.new(:foo,[],nil,t2)
-		t6 = MethodType.new(:bar,[],nil,t2)
-		t7 = MethodType.new(:foo,[],nil,t3)
-		assert(t4.eql?(t5), msg(t4, t5))
-		assert(!t4.eql?(t6), msg(t4, t6, true))
-		assert(!t4.eql?(t7), msg(t4, t7, true))
-	end
+  end
+
+  def test_method_no_arg
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = MethodType.new(:foo,[],nil,t1) 
+    t5 = MethodType.new(:foo,[],nil,t2)
+    t6 = MethodType.new(:bar,[],nil,t2)
+    t7 = MethodType.new(:foo,[],nil,t3)
+    assert(t4.eql?(t5), msg(t4, t5))
+    assert(!t4.eql?(t6), msg(t4, t6, true))
+    assert(!t4.eql?(t7), msg(t4, t7, true))
+  end
   
-	def test_method_one_arg
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = MethodType.new(:foo, [t1],nil,t3) 
-		t5 = MethodType.new(:foo, [t2],nil,t3)
-		t6 = MethodType.new(:foo, [],nil,t3)
-		assert(t4.eql?(t5), msg(t4, t5))
-		assert(!t4.eql?(t6), msg(t4, t6, true))
-	end
-
-	def test_method_one_arg_with_blk
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = BlockType.new([t1],nil,t3) 
-		t5 = BlockType.new([t2],nil,t3)
-		t6 = BlockType.new([],nil,t3)
+  def test_method_one_arg
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = MethodType.new(:foo, [t1],nil,t3) 
+    t5 = MethodType.new(:foo, [t2],nil,t3)
+    t6 = MethodType.new(:foo, [],nil,t3)
+    assert(t4.eql?(t5), msg(t4, t5))
+    assert(!t4.eql?(t6), msg(t4, t6, true))
+  end
+
+  def test_method_one_arg_with_blk
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = BlockType.new([t1],nil,t3) 
+    t5 = BlockType.new([t2],nil,t3)
+    t6 = BlockType.new([],nil,t3)
     t7 = MethodType.new(:foo, [t1], t4, t3)
     t8 = MethodType.new(:foo, [t2], t5, t3)
     t9 = MethodType.new(:bar, [t1], t4, t3)
     t10 = MethodType.new(:foo, [t1], t6, t3)
-		assert(t7.eql?(t8), msg(t7, t8))
-		assert(!t7.eql?(t9), msg(t7, t9, true))
-		assert(!t7.eql?(t10), msg(t7, t10, true))
-	end
-
-	def test_method_more_args
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = OptionalType.new(NominalType.new(Object))
-		t5 = VarLengthType.new(NominalType.new(String))
-		t6 = NominalType.new(BasicObject)
-		t7 = MethodType.new(:foo, [t1,t4,t5],nil,t3)
+    assert(t7.eql?(t8), msg(t7, t8))
+    assert(!t7.eql?(t9), msg(t7, t9, true))
+    assert(!t7.eql?(t10), msg(t7, t10, true))
+  end
+
+  def test_method_more_args
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = OptionalType.new(NominalType.new(Object))
+    t5 = VarLengthType.new(NominalType.new(String))
+    t6 = NominalType.new(BasicObject)
+    t7 = MethodType.new(:foo, [t1,t4,t5],nil,t3)
     t8 = MethodType.new(:foo, [t2,t4,t5],nil,t3)
     t9 = MethodType.new(:foo, [t1,t5,t4],nil,t3)
     t10 = MethodType.new(:foo, [t1,t4],nil,t3)
@@ -193,16 +193,16 @@ class ComparerTest < Test::Unit::TestCase
     assert(!t7.eql?(t10), msg(t7, t10, true))
     assert(!t7.eql?(t11), msg(t7, t11, true))
     assert(!t7.eql?(t12), msg(t7, t12, true))
-	end
+  end
 
   def test_method_lists
-		t1 = NominalType.new(String)
-		t2 = NominalType.new(String)
-		t3 = NominalType.new(Fixnum)
-		t4 = MethodType.new(:foo,[],nil,t1) 
-		t5 = MethodType.new(:foo,[],nil,t2)
-		t6 = MethodType.new(:bar,[],nil,t2)
-		t7 = MethodType.new(:foo,[],nil,t3)
+    t1 = NominalType.new(String)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = MethodType.new(:foo,[],nil,t1) 
+    t5 = MethodType.new(:foo,[],nil,t2)
+    t6 = MethodType.new(:bar,[],nil,t2)
+    t7 = MethodType.new(:foo,[],nil,t3)
     t8 = MethodListType.new([t4,t6])
     t9 = MethodListType.new([t5,t7])
     assert(!t8.eql?(t9), msg(t8, t9, true))

data/test/type/tc_parser.rb

@@ -211,6 +211,24 @@ class GrammarTest < Test::Unit::TestCase
     assert_equal("foo() -> nil", str)
   end
 
+  def test_multi_line_1
+    type = @parser.parse("foo(fixnum[to_s,to_i]) -> 
+                          fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum[to_i, to_s]) -> fixnum",str)    
+  end
+
+  def test_multi_line_2
+    type = @parser.parse("foo(fixnum[to_s,
+                                     to_i]) 
+                          -> 
+                          fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum[to_i, to_s]) -> fixnum",str)    
+  end
+
   def test_parse_fail_no_methname
     type = @parser.parse("() -> nil")
     assert_equal(nil, type, "Type signature without a method name")

data/test/type/tc_unparser.rb

@@ -68,6 +68,22 @@ class UnparserTest < Test::Unit::TestCase
     assert_equal("a*",str2)
   end
 
+  def test_star_duck_type()
+    t1 = DuckType.new([:foo, :bar])
+    t2 = VarLengthType.new(t1)
+    str2 = TypeUnparser.unparse(t2)
+    # puts str1
+    assert_equal("[bar, foo]*",str2)
+  end
+
+  def test_star_fusion_type()
+    t1 = FusionType.new(NominalType.new(A), [:foo, :bar])
+    t2 = VarLengthType.new(t1)
+    str2 = TypeUnparser.unparse(t2)
+    # puts str1
+    assert_equal("a[bar, foo]*",str2)
+  end
+
   def test_star_or_type()
     t1 = NominalType.new(A)
     t2 = NominalType.new(B)

data/test/typing/tc_typing.rb

@@ -59,26 +59,26 @@ class TypingTest < Test::Unit::TestCase
     assert(!t4.subtype_of?(t1), msg(t4,t1,true))
   end
 
-	def test_self()
-		SelfType.set_self(Fixnum)
-		t1 = SelfType.new()
-		t2 = SelfType.new()
-		SelfType.set_self(String)
-		t3 = SelfType.new()
-		t4 = NominalType.new(Numeric)
-		t5 = NominalType.new(String)
-		t6 = DuckType.new([:to_s])
-		assert(t1.subtype_of?(t2), msg(t1,t2))
-		assert(t2.subtype_of?(t1), msg(t2,t1))
-		assert(t1.subtype_of?(t3), msg(t1, t3))
-		assert(t3.subtype_of?(t1), msg(t3, t1))
-		assert(t1.subtype_of?(t4), msg(t1, t4))
-		assert(!t4.subtype_of?(t1), msg(t4, t1, true))
-		assert(!t1.subtype_of?(t5), msg(t1, t5, true))
-		assert(!t5.subtype_of?(t1), msg(t5, t1, true))
-		assert(t1.subtype_of?(t6), msg(t1, t5))
-		assert(!t6.subtype_of?(t1), msg(t5, t1, true))
-	end
+  def test_self()
+    SelfType.set_self(Fixnum)
+    t1 = SelfType.new()
+    t2 = SelfType.new()
+    SelfType.set_self(String)
+    t3 = SelfType.new()
+    t4 = NominalType.new(Numeric)
+    t5 = NominalType.new(String)
+    t6 = DuckType.new([:to_s])
+    assert(t1.subtype_of?(t2), msg(t1,t2))
+    assert(t2.subtype_of?(t1), msg(t2,t1))
+    assert(t1.subtype_of?(t3), msg(t1, t3))
+    assert(t3.subtype_of?(t1), msg(t3, t1))
+    assert(t1.subtype_of?(t4), msg(t1, t4))
+    assert(!t4.subtype_of?(t1), msg(t4, t1, true))
+    assert(!t1.subtype_of?(t5), msg(t1, t5, true))
+    assert(!t5.subtype_of?(t1), msg(t5, t1, true))
+    assert(t1.subtype_of?(t6), msg(t1, t5))
+    assert(!t6.subtype_of?(t1), msg(t5, t1, true))
+  end
 
   def test_duck_types_id()
     t1 = DuckType.new([:foo,:baz]) 

data/webpage/footer.html

@@ -1,5 +1,5 @@
 
-	</div>
+  </div>
   </center>
 </body>
 </html>

data/webpage/header.html

@@ -2,13 +2,13 @@
 <head>
   <title>RubyBreaker</title>
   <LINK REL=StyleSheet HREF="rubybreaker.css" TYPE="text/css">
-	<script type="text/javascript" src="generated_toc.js">  </script>
+  <script type="text/javascript" src="generated_toc.js">  </script>
 </head>
 <body onLoad="createTOC()">
   <center>
-	<div id="content">
-		<div id="logo">
-			<img src="images/logo.png" border="0">
-		</div>
-		<hr />
-		<div id="generated-toc"></div>
+  <div id="content">
+    <div id="logo">
+      <img src="images/logo.png" border="0">
+    </div>
+    <hr />
+    <div id="generated-toc"></div>

data/webpage/index.html

@@ -2,16 +2,16 @@
 <head>
   <title>RubyBreaker</title>
   <LINK REL=StyleSheet HREF="rubybreaker.css" TYPE="text/css">
-	<script type="text/javascript" src="generated_toc.js">  </script>
+  <script type="text/javascript" src="generated_toc.js">  </script>
 </head>
 <body onLoad="createTOC()">
   <center>
-	<div id="content">
-		<div id="logo">
-			<img src="images/logo.png" border="0">
-		</div>
-		<hr />
-		<div id="generated-toc"></div>
+  <div id="content">
+    <div id="logo">
+      <img src="images/logo.png" border="0">
+    </div>
+    <hr />
+    <div id="generated-toc"></div>
 <hr />
 
 <h1>Introduction</h1>
@@ -32,6 +32,11 @@ 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>
 
+<p>To contribute to the project, visit RubyBreaker's
+<a href="http://github.com/rockalizer/rubybreaker">GitHub page</a> and
+<a href="http://rubygems.org/gems/rubybreaker">RubyGems page</a>. RubyBreaker RDoc can
+be found in <a href="rdoc/index.html">here</a>.</p>
+
 <h2>Limitations</h2>
 
 <ul>
@@ -192,11 +197,34 @@ signature <code>bar(fixnum[to_s]) -&gt; string</code>, which means it takes an o
 has <code>Fixnum</code>'s <code>to_s</code> method and returns a string. More detail on the type
 annotation language will be explained in later section.</p>
 
-<p>Currently, both <code>Breakable</code> and <code>Broken</code> only support instance methods.
-Furthermore, class and module methods can neither be monitored nor used for
-analysis. It is important to keep in mind that <code>Broken</code> module always wins.
-In other words, if a module is declared as both <code>Broken</code> and <code>Breakable</code>, it
-is treated as <code>Broken</code>.</p>
+<p>It is possible to include either <code>Breakable</code> or <code>Broken</code> in an eigen-class
+to document class methods. To make this easier, RubyBreaker will
+automatically support auto-documentation and manual documentation of class
+methods if the original module is declared as <code>Breakable</code> or <code>Broken</code>,
+respectively--that is, up to immediate eigen class level of a "nominal"
+module.  The following example shows how class methods can be
+auto-documented and manually documented, respectively.</p>
+
+<pre><code>require "rubybreaker"
+class A
+  include RubyBreaker::Breakable
+  class &lt;&lt; self
+    def foo(x); x.to_s end
+  end
+end
+class B
+  include RubyBreaker::Broken
+  class &lt;&lt; self
+    typesig("foo(fixnum[to_s]) -&gt; string")
+    def foo(x); x.to_s end
+  end
+end
+</code></pre>
+
+<p>Keep in mind that <code>Broken</code> module always wins against <code>Breakable</code>.  In other
+words, if a module is declared as both <code>Broken</code> and <code>Breakable</code>, it is
+treated as <code>Broken</code>. Future versions of RubyBreaker will support a hybrid of
+the two modules, but it remains as a limitation in the current version.</p>
 
 <h3>Program Entry Point</h3>
 
@@ -325,7 +353,7 @@ it should be only used for an object that requires an arbitrary yet most
 specific type--that is, <code>?</code> is a subtype of any other type, but any
 other type is not a subtype of <code>?</code>. This becomes a bit complicated for
 method or block argument types because of their contra-variance
-characteristic. Please kefer to the section <em>Subtyping</em>.</p>
+characteristic. Please refer to the section <em>Subtyping</em>.</p>
 
 <h3>Block Type</h3>
 
@@ -399,25 +427,34 @@ subsequent "promotions").</p>
 
 <h2>Type System</h2>
 
-<p>RubyBreaker comes with its own type system that is used to document type
-information. This section describes how RubyBreaker determines which type(s)
-to document. <em>More documentation coming soon...</em></p>
-
-<h3>Subtyping</h3>
-
-<p><em>Documentation coming soon...</em></p>
-
-<h3>Subtyping vs. Subclassing</h3>
-
-<p><em>Documentation coming soon...</em></p>
+<p>RubyBreaker comes with its own type system to auto-document the type
+information. Each method in a <code>Breakable</code> module is dynamically instrumented
+to be monitored during runtime. This monitoring code observes the types of
+the arguments, block, and return value of each method. Once this information
+is gathered, RubyBreaker will compare it to the information gathered so far.
+If these two types are "compatiable", RubyBreaker will choose more general
+type of the two. Otherwise, RubyBreaker will use the method list type to
+accommodate two "incompatible" types.</p>
+
+<h3>Subtyping and Subclassing</h3>
+
+<p>RubyBreaker uses subtyping to choose one from the two "compatible" types.
+Two types are "compatible" if one is subtype of another. This means that the
+<em>subtype</em> can be represented using the <em>supertype</em> instead. This is why
+RubyBrekaer chooses the latter to document both types. RubyBreaker relies on
+subclassing of Ruby to determine a subtyping relationship between two types.
+For example, <code>Fixnum</code> is considered to be subtype of <code>Numeric</code> since the
+former is subclass of the latter. (Strictly speaking, <code>Fixnum</code> is not really
+subtype of <code>Numeric</code> because some methods are overriden in <code>Fixnum</code> with
+method types that are not subtype of the counterparts in <code>Numeric</code>. But,
+RubyBreaker is lenient and considers them compatible--that is, <code>Numeric</code> can
+represent any <code>Fixnum</code>.</p>
 
 <h3>Pluggable Type System (Advanced)</h3>
 
 <p>Yes, RubyBreaker was designed with the replaceable type system in mind. In
 other words, anyone can write his own type system and plug it into
-RubyBreaker.</p>
-
-<p><em>Documentation coming soon...</em></p>
+RubyBreaker. <em>Technical documentation coming soon...</em></p>
 
 <hr />
 
@@ -433,7 +470,7 @@ respect to a nominal type.</p>
 
 <p>Copyright (c) 2012 Jong-hoon (David) An. All Rights Reserved.</p>
 
-	</div>
+  </div>
   </center>
 </body>
 </html>