rubybreaker 0.0.6 → 0.0.7

data/lib/rubybreaker/runtime/pluggable.rb

@@ -31,13 +31,19 @@ module RubyBreaker
     # default type system that comes with RubyBreaker.
     module Pluggable
 
+      def check_before_method_call(obj, meth_info)
+      end 
+
+      def check_after_method_call(obj, meth_info)
+      end
+
       # This method will be invoked right before the actual method is
       # invoked.
       #
       # obj:: the receiver of the method call (message)
       # method_info:: a MethodInfo object containing the method call
       #               information
-      def before_method_call(obj, meth_info)
+      def break_before_method_call(obj, meth_info)
       end
 
       # This method will be invoked right after the actual method is
@@ -46,7 +52,7 @@ module RubyBreaker
       # obj:: the receiver of the method call (message)
       # method_info:: a MethodInfo object containing the method call
       #               information
-      def after_method_call(obj, meth_info)
+      def break_after_method_call(obj, meth_info)
       end
 
     end

data/lib/rubybreaker/runtime/type_system.rb

@@ -3,7 +3,8 @@
 # subtyping defined in ../typing/subtyping.rb. It is not a constraint-based
 # type system and does not check type errors statically. The main purpose of
 # this type system is to give a readable type signature to every method in
-# designated modules and classes.
+# modules/classes specified for "breaking" and to type check documented
+# methods of modules/classes specified for "checking".
 
 require_relative "util"
 require_relative "object_wrapper"
@@ -117,7 +118,7 @@ module RubyBreaker
         exist_meth_type = meth_type_map[meth_name.to_sym] 
         
         # Again, find the arity
-        meth_obj = obj.method(MonitorUtils.get_alt_meth_name(meth_name))
+        meth_obj = obj.method(Monitor.get_alt_meth_name(meth_name))
         arity = meth_obj.arity
 
         # Construct the newly observed method type first
@@ -165,14 +166,79 @@ module RubyBreaker
         if !resolved
           exist_meth_type.types << new_meth_type
         end
+
+      end
+
+      # This method creates the prefix for the type error message.
+      def type_error_msg_prefix(mod, meth_name)
+        result = /#<Class:(.+)>/.match("#{mod}")
+        prefix = result ? "#{result[1]}." : "#{mod}#"
+        return "#{prefix}#{meth_name}"
       end
 
       public
+
+      # This method is invoked before the original method is executed.
+      def check_before_method(obj, meth_info)
+        is_obj_mod = (obj.class == Class or obj.class == Module)
+        mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
+
+        meth_type_map = TYPE_MAP[mod]
+        return unless meth_type_map
+
+        # Let's take things out of the MethodInfo object
+        meth_name = meth_info.meth_name
+        args = meth_info.args
+        blk = meth_info.blk
+        ret = meth_info.ret
+
+        # Get the registered method type for this method
+        meth_type = meth_type_map[meth_name]
+
+        args.each_with_index do |arg, i|
+          arg_type = NominalType.new(arg.class)
+          if !arg_type.subtype_of?(meth_type.arg_types[i])
+            msg = type_error_msg_prefix(mod, meth_name) +
+                  "'s #{Util.ordinalize(i+1)} argument " +
+                  "does not have type #{arg_type.unparse()}."
+            raise Errors::TypeError.new(msg)
+          end
+        end
+
+      end
+
+      # This method is invoked after the original method is executed.
+      def check_after_method(obj, meth_info)
+        is_obj_mod = (obj.class == Class or obj.class == Module)
+        mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
+
+        meth_type_map = TYPE_MAP[mod]
+        return unless meth_type_map
+
+        # Let's take things out of the MethodInfo object
+        meth_name = meth_info.meth_name
+        args = meth_info.args
+        blk = meth_info.blk
+        ret = meth_info.ret
+
+        # Get the registered method type for this method
+        meth_type = meth_type_map[meth_name]
+
+        ret_type = NominalType.new(ret.class)
+        if !meth_type.ret_type.subtype_of?(ret_type)
+          msg = type_error_msg_prefix(mod, meth_name) +
+                " return value does not have type #{ret_type.unparse()}."
+          raise Errors::TypeError.new(msg)
+        end
+      end
       
-      # This method occurs before every "monitored" method call. It wraps
-      # each argument with the object wrapper.
-      def before_method(obj, meth_info)
+      # This method occurs before every call to a "monitored" method in a
+      # module/class specified for breaking. It wraps each argument with the
+      # object wrapper so it can be tracked of the method calls. 
+      def break_before_method(obj, meth_info)
 
+        # Use the eigen class if the object is a module/class and use the
+        # object's class otherwise.
         is_obj_mod = (obj.class == Class or obj.class == Module)
         mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
 
@@ -201,7 +267,7 @@ module RubyBreaker
           # This means the method type has been created previously.
           unless (blk == nil && meth_type.blk_type == nil) &&
                  (!blk || blk.arity == meth_type.blk_type.arg_types.length)
-            raise Errors::TypeError("Block usage is inconsistent")
+            raise Errors::TypeError.new("Block usage is inconsistent")
           end
         else
           # No method type has been created for this method yet. Create a
@@ -210,7 +276,7 @@ module RubyBreaker
           #
           # First, use the orignal method's arity to find out # of
           # arguments. 
-          meth_obj = obj.method(MonitorUtils.get_alt_meth_name(meth_name))
+          meth_obj = obj.method(Monitor.get_alt_meth_name(meth_name))
           arity = meth_obj.arity
           arg_types = [nil] * meth_obj.arity.abs 
           if blk
@@ -229,9 +295,10 @@ module RubyBreaker
 
       end
 
-      # This method occurs after every "monitored" method call. It updates
-      # the type information.
-      def after_method(obj, meth_info)
+      # This method occurs after every call to a "monitored" method call of
+      # a module/class specified for "breaking". It updates the type
+      # information.
+      def break_after_method(obj, meth_info)
 
         is_obj_mod = (obj.class == Class or obj.class == Module)
         mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class

data/lib/rubybreaker/task.rb

@@ -24,6 +24,9 @@ module Rake
     # List of modules/classes to break
     attr_accessor :break
 
+    # List of modules/classes to check
+    attr_accessor :check
+
     # RubyBreaker options
     attr_accessor :rubybreaker_opts
 
@@ -41,6 +44,7 @@ module Rake
       # Initialize extra instance variables
       @rubybreaker_opts = []
       @break = nil
+      @check = nil
 
       # Call the original constructor first
       super(taskname, *args, &blk)
@@ -60,11 +64,13 @@ module Rake
         :name => taskname,
         :rubybreaker_opts => opts,
         :break => [], # Set doesn't work well with YAML; just use an array
+        :check => [],
         :test_files => @test_files,
       }
 
       # This allows a bulk declaration of Breakable modules/classes
       @break.each { |b| config[:break] << b } if @break
+      @check.each { |c| config[:check] << c } if @check
 
       # This code segment is a clever way to store yaml data in a ruby file
       # that reads its own yaml data after __END__ when loaded.

data/lib/rubybreaker/util.rb

@@ -8,6 +8,29 @@ module RubyBreaker
   # in the project.
   module Util
 
+    def self.uneigen(mod_str)
+      result = /^#<Class:(.+)>#/.match(mod_str)
+      if result 
+        return result[0]
+      else
+        return mod_str
+      end
+    end
+
+    # File lib/active_support/inflector.rb, line 295
+    def self.ordinalize(number)
+      if (11..13).include?(number.to_i % 100)
+        "#{number}th"
+      else
+        case number.to_i % 10
+          when 1; "#{number}st"
+          when 2; "#{number}nd"
+          when 3; "#{number}rd"
+          else    "#{number}th"
+        end
+      end
+    end
+
     # File activesupport/lib/active_support/inflector/methods.rb, line 48
     def self.underscore(camel_cased_word)
       word = camel_cased_word.to_s.dup

data/test/integrated/tc_checking.rb

@@ -0,0 +1,71 @@
+require "test/unit"
+require_relative "../../lib/rubybreaker"
+
+class IntegratedCheckingTest < Test::Unit::TestCase
+  include RubyBreaker
+
+  class A
+
+    typesig("f1(fixnum) -> string")
+    def f1(x); x.to_s end
+
+    typesig("f2(fixnum[to_s]) -> string")
+    def f2(x); x.to_s end
+
+    typesig("f3(fixnum[foo, to_s]) -> string")
+    def f3(x); x.to_s end
+
+    typesig("f4(fixnum) -> fixnum")
+    def f4(x); x.to_s end
+
+    typesig("f5(fixnum, fixnum) -> fixnum")
+    def f5(x,y); x+y end
+
+  end
+
+  def setup()
+    RubyBreaker.check(A)
+  end
+
+  def test_nominal()
+    a = A.new
+    assert_nothing_thrown do
+      a.f1(2)
+    end
+    assert_raise RubyBreaker::Errors::TypeError do
+      a.f1("2")
+    end 
+  end
+
+  def test_duck()
+    a = A.new
+    assert_nothing_thrown do
+      a.f2(2)
+      a.f3(2) # This will pass too
+    end
+    assert_raise RubyBreaker::Errors::TypeError do
+      a.f3("2")
+    end 
+  end
+
+  def test_ret()
+    a = A.new
+    assert_raise RubyBreaker::Errors::TypeError do
+      a.f4(2)
+    end
+  end
+
+  def test_two_fixnums()
+    a = A.new
+    assert_nothing_thrown do
+      a.f5(1, 2)
+    end
+    assert_raise RubyBreaker::Errors::TypeError do
+      a.f5("1", 2)
+    end
+    assert_raise RubyBreaker::Errors::TypeError do
+      a.f5(1, "2")
+    end
+  end
+
+end

data/test/integrated/tc_class_methods.rb

@@ -10,13 +10,14 @@ class IntegratedClassMethodsTest < Test::Unit::TestCase
 
   class B
     class << self
-      typesig("bar(fixnum[to_s]) -> string")
+      typesig("bar(fixnum[+]) -> string")
       def bar(x); x.to_s end
     end
   end
 
   def setup()
-    RubyBreaker.break(A, B)
+    RubyBreaker.break(A)
+    RubyBreaker.check(B)
   end
 
   def test_class_methods
@@ -26,10 +27,19 @@ class IntegratedClassMethodsTest < Test::Unit::TestCase
     assert_equal("foo(fixnum[to_s]) -> string", str)
   end
 
-  def test_broken_class_methods
+  def test_documented_class_methods
     b_bar_meth_type = Runtime::Inspector.inspect_class_meth(B, :bar)
     str = RubyBreaker::TypeUnparser.unparse(b_bar_meth_type)
-    assert_equal("bar(fixnum[to_s]) -> string", str)
+    assert_equal("bar(fixnum[+]) -> string", str)
+  end
+
+  def test_type_checking
+    assert_nothing_thrown do
+      B.bar(1)
+    end
+    assert_raise Errors::TypeError do
+      B.bar(:abc)
+    end
   end
 
 end

data/test/testtask/sample.rb

@@ -6,5 +6,6 @@ end
 
 class SampleClassB
   def foo(x); x.to_s end
+  def bar(x); x.to_s end
 end
 

data/test/testtask/tc_testtask.rb

@@ -4,22 +4,34 @@ require "rubybreaker"
 
 class SampleClassB # re-opening
   typesig("foo(fixnum[to_s]) -> string")
+  typesig("bar(fixnum) -> string")
 end
 
 class RubyBreakerTestTaskTest < Test::Unit::TestCase
+  include RubyBreaker
 
   def test_break()
     SampleClassA.new.foo(2)
-    t = RubyBreaker::Runtime::Inspector.inspect_meth(SampleClassA, :foo)
+    t = Runtime::Inspector.inspect_meth(SampleClassA, :foo)
     str = t.unparse()
     assert_equal("foo(fixnum[to_s]) -> string", str)
   end
 
   def test_documented()
-    t = RubyBreaker::Runtime::Inspector.inspect_meth(SampleClassB, :foo)
+    t = Runtime::Inspector.inspect_meth(SampleClassB, :foo)
     str = t.unparse()
     assert_equal("foo(fixnum[to_s]) -> string", str)
   end
 
+  def test_type_checking()
+    b = SampleClassB.new
+    assert_nothing_thrown do 
+      b.foo(1)
+    end
+    assert_raise Errors::TypeError do
+      b.bar(:"1")
+    end
+  end
+
 end
 

data/test/ts_integrated.rb

@@ -6,3 +6,4 @@ require_relative "integrated/tc_inherit_broken"
 require_relative "integrated/tc_class_methods"
 require_relative "integrated/tc_both_documented_and_undocumented"
 require_relative "integrated/tc_namespace"
+require_relative "integrated/tc_checking"

data/webpage/index.html

@@ -40,7 +40,6 @@ and effectively.</p>
 
 <ul>
 <li>Auto-document block arguments (inherent)</li>
-<li>Perform early dynamic type checks</li>
 <li>Support parametric polymorphic types</li>
 <li>Support RDoc or YARD output format</li>
 </ul>
@@ -49,7 +48,7 @@ and effectively.</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>. The web version of
-this document can be found
+this document and the tutorial can be found
 <a href="http://rockalizer.webfactional.com/projects/rubybreaker">here</a>.</p>
 
 <h2>Requirements</h2>

data/webpage/rdoc/Object.html

@@ -116,8 +116,6 @@
   
     <li><a href="./RubyBreaker/Runtime/MonitorSwitch.html">RubyBreaker::Runtime::MonitorSwitch</a>
   
-    <li><a href="./RubyBreaker/Runtime/MonitorUtils.html">RubyBreaker::Runtime::MonitorUtils</a>
-  
     <li><a href="./RubyBreaker/Runtime/ObjectWrapper.html">RubyBreaker::Runtime::ObjectWrapper</a>
   
     <li><a href="./RubyBreaker/Runtime/Pluggable.html">RubyBreaker::Runtime::Pluggable</a>

data/webpage/rdoc/Rake.html

@@ -110,8 +110,6 @@
   
     <li><a href="./RubyBreaker/Runtime/MonitorSwitch.html">RubyBreaker::Runtime::MonitorSwitch</a>
   
-    <li><a href="./RubyBreaker/Runtime/MonitorUtils.html">RubyBreaker::Runtime::MonitorUtils</a>
-  
     <li><a href="./RubyBreaker/Runtime/ObjectWrapper.html">RubyBreaker::Runtime::ObjectWrapper</a>
   
     <li><a href="./RubyBreaker/Runtime/Pluggable.html">RubyBreaker::Runtime::Pluggable</a>

data/webpage/rdoc/Rake/RubyBreakerTestTask.html

@@ -130,8 +130,6 @@
   
     <li><a href="../RubyBreaker/Runtime/MonitorSwitch.html">RubyBreaker::Runtime::MonitorSwitch</a>
   
-    <li><a href="../RubyBreaker/Runtime/MonitorUtils.html">RubyBreaker::Runtime::MonitorUtils</a>
-  
     <li><a href="../RubyBreaker/Runtime/ObjectWrapper.html">RubyBreaker::Runtime::ObjectWrapper</a>
   
     <li><a href="../RubyBreaker/Runtime/Pluggable.html">RubyBreaker::Runtime::Pluggable</a>
@@ -248,6 +246,19 @@ t.break = [&quot;SampleClassA&quot;]</pre>
         </div>
       </div>
       
+      <div id="attribute-i-check" class="method-detail">
+        <div class="method-heading attribute-method-heading">
+          <span class="method-name">check</span><span
+            class="attribute-access-type">[RW]</span>
+        </div>
+
+        <div class="method-description">
+        
+        <p>List of modules/classes to check</p>
+        
+        </div>
+      </div>
+      
       <div id="attribute-i-rubybreaker_opts" class="method-detail">
         <div class="method-heading attribute-method-heading">
           <span class="method-name">rubybreaker_opts</span><span
@@ -288,12 +299,13 @@ options and store them in a yaml file.</p>
 
           
           <div class="method-source-code" id="new-source">
-            <pre><span class="ruby-comment"># File lib/rubybreaker/task.rb, line 39</span>
+            <pre><span class="ruby-comment"># File lib/rubybreaker/task.rb, line 42</span>
     <span class="ruby-keyword">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">taskname</span>=<span class="ruby-string">&quot;&quot;</span>, *<span class="ruby-identifier">args</span>, &amp;<span class="ruby-identifier">blk</span>)
 
       <span class="ruby-comment"># Initialize extra instance variables</span>
       <span class="ruby-ivar">@rubybreaker_opts</span> = []
       <span class="ruby-ivar">@break</span> = <span class="ruby-keyword">nil</span>
+      <span class="ruby-ivar">@check</span> = <span class="ruby-keyword">nil</span>
 
       <span class="ruby-comment"># Call the original constructor first</span>
       <span class="ruby-keyword">super</span>(<span class="ruby-identifier">taskname</span>, *<span class="ruby-identifier">args</span>, &amp;<span class="ruby-identifier">blk</span>)
@@ -313,11 +325,13 @@ options and store them in a yaml file.</p>
         <span class="ruby-value">:name</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">taskname</span>,
         <span class="ruby-value">:rubybreaker_opts</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">opts</span>,
         <span class="ruby-value">:break</span> =<span class="ruby-operator">&gt;</span> [], <span class="ruby-comment"># Set doesn't work well with YAML; just use an array</span>
+        <span class="ruby-value">:check</span> =<span class="ruby-operator">&gt;</span> [],
         <span class="ruby-value">:test_files</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@test_files</span>,
       }
 
       <span class="ruby-comment"># This allows a bulk declaration of Breakable modules/classes</span>
       <span class="ruby-ivar">@break</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">b</span><span class="ruby-operator">|</span> <span class="ruby-identifier">config</span>[<span class="ruby-value">:break</span>] <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">b</span> } <span class="ruby-keyword">if</span> <span class="ruby-ivar">@break</span>
+      <span class="ruby-ivar">@check</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span> <span class="ruby-identifier">config</span>[<span class="ruby-value">:check</span>] <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">c</span> } <span class="ruby-keyword">if</span> <span class="ruby-ivar">@check</span>
 
       <span class="ruby-comment"># This code segment is a clever way to store yaml data in a ruby file</span>
       <span class="ruby-comment"># that reads its own yaml data after __END__ when loaded.</span>
@@ -381,7 +395,7 @@ __END__
 
           
           <div class="method-source-code" id="breakable-source">
-            <pre><span class="ruby-comment"># File lib/rubybreaker/task.rb, line 31</span>
+            <pre><span class="ruby-comment"># File lib/rubybreaker/task.rb, line 34</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier">breakable</span>(); <span class="ruby-ivar">@break</span> <span class="ruby-keyword">end</span></pre>
           </div><!-- breakable-source -->
           
@@ -409,7 +423,7 @@ __END__
 
           
           <div class="method-source-code" id="breakable-3D-source">
-            <pre><span class="ruby-comment"># File lib/rubybreaker/task.rb, line 34</span>
+            <pre><span class="ruby-comment"># File lib/rubybreaker/task.rb, line 37</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier">breakable=</span>(*<span class="ruby-identifier">args</span>); <span class="ruby-keyword">self</span>.<span class="ruby-identifier">break</span>(*<span class="ruby-identifier">args</span>) <span class="ruby-keyword">end</span></pre>
           </div><!-- breakable-3D-source -->