rubybreaker 0.0.4 → 0.0.5

data/lib/rubybreaker/runtime/inspector.rb

@@ -1,6 +1,6 @@
 #--
 # This file defines the type inspector which fetches the type information
-# gathered or documented in a Breakable, Broken, or hybrid module.
+# gathered or documented in a class.
 
 require_relative "util"
 require_relative "monitor"
@@ -9,26 +9,14 @@ module RubyBreaker
 
   module Runtime
   
-    # This module inspects a Breakable module, a Broken module, or a hybrid
-    # module to fetch the type information for each method.
+    # This module inspects type information gathered so far.
     module Inspector
       
       # This method inspects the module for the type of the specified
-      # method. It returns the method type or method list type for the given
-      # method, by looking at, first, the placeholder for the Breakable
-      # side of the module, and then, the placeholder for the Broken side of
-      # the module. If no method exists or if there is no type information
-      # for the method, it returns nil.
+      # method.
       def self.inspect_meth(mod, mname)
         mname = mname.to_sym 
-        if Breakable::TYPE_PLACEHOLDER_MAP.has_key?(mod)
-          placeholder = Breakable::TYPE_PLACEHOLDER_MAP[mod]
-        end
-        t = placeholder.meth_type_map[mname] if placeholder
-        if !t && Broken::TYPE_PLACEHOLDER_MAP.has_key?(mod)
-          placeholder = Broken::TYPE_PLACEHOLDER_MAP[mod]
-          t = placeholder.meth_type_map[mname] if placeholder
-        end
+        t = TYPE_MAP[mod][mname] if TYPE_MAP.has_key?(mod)
         return t
       end
 
@@ -52,18 +40,8 @@ module RubyBreaker
       # containing (method name, method type) pairs.
       def self.inspect_all(mod)
         mtypes = {}
-        mm = Breakable::TYPE_PLACEHOLDER_MAP[mod]
-        if mm
-          mm.meth_type_map.each_pair {|im,mtype|
-            mtypes[im] = mtype if mtype 
-          }
-        end
-        mm = Broken::TYPE_PLACEHOLDER_MAP[mod]
-        if mm
-          mm.meth_type_map.each_pair {|im,mtype|
-            mtypes[im] = mtype if mtype 
-          }
-        end
+        mm = TYPE_MAP[mod]
+        mm.each_pair {|im,mtype| mtypes[im] = mtype if mtype } if mm
         return mtypes
       end 
       

data/lib/rubybreaker/runtime/monitor.rb

@@ -1,14 +1,12 @@
 #--
 # This file contains the core of the runtime framework which injects the
-# monitoring code into Breakable classes/modules and actually monitors the
+# monitoring code into breakable classes/modules and actually monitors the
 # instances of those classes/modules at runtime. It also provides some utility
 # functions for later use (after runtime).
 
 dir = File.dirname(__FILE__) 
 require_relative "util"
 require_relative "../debug"
-require_relative "type_placeholder"
-require_relative "pluggable"
 require_relative "type_system"
 
 module RubyBreaker
@@ -132,11 +130,11 @@ module RubyBreaker
         mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
 
         # mm = get_module_monitor(mod) unless is_obj_mod
-        mm = Breakable::MONITOR_MAP[mod] 
+        mm = MONITOR_MAP[mod] 
 
         # There is something wrong if there isn't a module monitor
         # associated with the call.
-        # raise Exception if mm == nil || !mm.meth_type_map.include?(meth_name)
+        # raise Exception if mm == nil || !mm.include?(meth_name)
 
         meth_info = MethodInfo.new(meth_name, args, blk, nil)
 
@@ -212,24 +210,30 @@ module RubyBreaker
 
         RubyBreaker.log("Installing module monitor for #{mod}")
 
-        Breakable::MONITOR_MAP[mod] = Monitor.new(mod, DEFAULT_TYPE_SYSTEM)
-        Breakable::TYPE_PLACEHOLDER_MAP[mod] = TypePlaceholder.new
+        # Do not re-install monitor if already done so.
+        if MONITOR_MAP[mod] 
+          RubyBreaker.log("Skip #{mod} as it has a monitor installed.")
+          return
+        end
+
+        MONITOR_MAP[mod] = Monitor.new(mod, DEFAULT_TYPE_SYSTEM)
 
-        meth_type_map = []
+        # Create the type map if it does not exist already. Remember, this
+        # map could have been made by typesig().
+        TYPE_MAP[mod] = {} unless TYPE_MAP[mod]
+
+        # Get the list of instance methods but do not include inherited
+        # methods. Those are part of the owner's not this module.
         meths = mod.instance_methods(false)  
 
-        # RubyBreaker now supports the hybrid of Breakable and Broken. Here,
-        # see if any methods are already broken.
-        broken_meth_type_map = Inspector.inspect_all(mod)
-        broken_meths = broken_meth_type_map.keys
+        # See if any method is already broken (explicitly typesig'ed)
+        broken_mt_map = Inspector.inspect_all(mod)
+        broken_meths = broken_mt_map.keys
 
         meths.each do |m| 
-          # As long as the method is not "Broken" yet, it is considered
-          # Breakable (if the module is declared to be Breakable).
-          unless broken_meths.include?(m)
-            self.rename_meth(mod,m) 
-          end 
+          self.rename_meth(mod,m) unless broken_meths.include?(m)
         end
+
       end
 
     end

data/lib/rubybreaker/runtime/object_wrapper.rb

@@ -70,11 +70,16 @@ module RubyBreaker
       def method_missing(mname,*args,&blk)
         ::RubyBreaker.log("Method_missing for #{mname}")
         if GLOBAL_MONITOR_SWITCH.switch
+          # Must handle send method specially (do not track them)
+          if [:"__send__", :send].include?(mname)
+            mname = args[0]
+            args = args[1..-1]
+          end
           @__rubybreaker_type.add_meth(mname)
-          retval =  @__rubybreaker_obj.send(mname,*args,&blk)
+          retval =  @__rubybreaker_obj.send(mname, *args, &blk)
           retval = ObjectWrapper.new(retval)
         else
-          retval = @__rubybreaker_obj.send(mname,*args,&blk)
+          retval = @__rubybreaker_obj.send(mname, *args, &blk)
         end
         return retval
       end

data/lib/rubybreaker/runtime/type_system.rb

@@ -7,10 +7,10 @@
 
 require_relative "util"
 require_relative "object_wrapper"
-require_relative "type_placeholder"
 require_relative "../type"
 require_relative "../typing"
 require_relative "../debug"
+require_relative "pluggable"
 
 module RubyBreaker
 
@@ -176,7 +176,7 @@ module RubyBreaker
         is_obj_mod = (obj.class == Class or obj.class == Module)
         mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
 
-        meth_type_map = Breakable::TYPE_PLACEHOLDER_MAP[mod].meth_type_map
+        meth_type_map = TYPE_MAP[mod]
 
         # Let's take things out of the MethodInfo object
         meth_name = meth_info.meth_name
@@ -244,10 +244,8 @@ module RubyBreaker
 
         RubyBreaker.log("In module monitor_after #{meth_name}")
 
-        meth_type_map = Breakable::TYPE_PLACEHOLDER_MAP[mod].meth_type_map
-
         # Compute the least upper bound
-        lub(obj, meth_type_map,meth_name,retval,*args,&blk)
+        lub(obj, TYPE_MAP[mod],meth_name,retval,*args,&blk)
 
         if obj == retval  
           # It is possible that the method receiver is a wrapped object if

data/lib/rubybreaker/runtime/typesig_unparser.rb

@@ -6,7 +6,7 @@ module RubyBreaker
   module Runtime
 
     # This module handles unparsing type signatures.
-    module TypesigUnparser
+    module TypeSigUnparser
 
       include TypeDefs
 
@@ -51,9 +51,6 @@ module RubyBreaker
         
         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)

data/lib/rubybreaker/runtime.rb

@@ -1,8 +1,7 @@
 #--
-# This file defines Breakable and Broken module. Breakable module makes the
-# hosting module (and class) subject to type monitoring. Broken module makes
-# type information of the hosting module accessible.
-
+# This file provides two methods breakable() and broken() that declares a
+# module/class to be monitored
+require "set"
 require_relative "runtime/overrides"
 require_relative "runtime/typesig_parser"
 require_relative "runtime/typesig_unparser"
@@ -11,122 +10,82 @@ require_relative "runtime/inspector"
 
 module RubyBreaker
 
-  # Broken takes higher precedence than Breakable. Once a module is
-  # "declared" to be Broken, it cannot be Breakable. 
-  #
-  # TODO: In future, there will be a hybrid of two to allow documenting of
-  #       methods that are newly introduced in a broken class/module.
+  module Runtime
 
-  # This array lists modules/classes that will be monitored.
-  BREAKABLE = []
+    # This set keeps track of modules/classes that will be monitored.
+    # *DEPRECATED* : Use +breakable+ method instead.
+    BREAKABLES = Set.new 
 
-  # This array lists "broken" classes--i.e., with type signatures
-  BROKEN = []
+    # This hash maps a module to a nested hash that maps a method name to a
+    # method type. This hash is shared between breakable modules/classes and
+    # non-breakable modules/classes.
+    TYPE_MAP = {} # module => {:meth_name => type}
 
-  # This module should be included in classes or modules that you want to
-  # monitor during runtime. The concept is that once a Breakable module is
-  # monitored and its type documentation is generated, the module now becomes
-  # a Broken module. The actual implementation is a simple trigger that 
-  # queues the target module into the list of modules to monitor. The queued
-  # modules are then modified to be monitored dynamically.
-  module Breakable
+    # This hash maps a (breakable) module to a type monitor
+    MONITOR_MAP = {}  # module => monitor
 
-    TYPE_PLACEHOLDER_MAP = {} # module => type_placeholder
-    MONITOR_MAP = {}          # module => monitor
+    # This set lists modules/classes that are actually instrumented with a
+    # monitor.
+    INSTALLED = Set.new
 
-    # Simply keep track of this module and its eigen class so they are
-    # monitored later on.
-    def self.included(mod)
-      BREAKABLE << mod
-      BREAKABLE << Runtime.eigen_class(mod)
+    # This method installs a monitor for each breakable module. 
+    # *DEPRECATED*: Use +breakable()+ method instead.
+    def self.instrument() 
+      BREAKABLES.each do |mod|
+        # Duplicate checks in place in these calls.
+        MonitorInstaller.install_module_monitor(mod)
+        INSTALLED << mod
+      end
     end
 
-  end
-
-  # This module is included for "broken" classes.
-  module Broken
-
-    include TypeDefs
-    include Runtime
-
-    TYPE_PLACEHOLDER_MAP = {} # module => type_placeholder
- 
-    #-
-    # This module will be "extended" to the eigen class of the class that 
-    # includes Broken module. This allows the eigen class to call 'typesig' 
-    # method to parse the type signature dynamically.
-    # 
-    # Usage:
-    #   Class A
-    #     include RubyBreaker::Broken
-    #
-    #     typesig("foo(fixnum) -> fixnum")
-    #     def foo(x) ... end
-    #   end
-    #
-    module BrokenEigen
-
-      include TypeDefs
-      include Runtime
-
-      # This method can be used at the eigen level of the target module to
-      # specify the type of a method.
-      def typesig(str)
-
-        # This MUST BE set for self type to work in type signatures.
-        TypeDefs::SelfType.set_self(self) 
-
-        t = TypeSigParser.parse(str)
-        placeholder = TYPE_PLACEHOLDER_MAP[self]
-        if placeholder
-          meth_type = placeholder.meth_type_map[t.meth_name]
-          if meth_type
-            # TODO: make a method list
-            if meth_type.instance_of?(MethodListType)
-              meth_type.types << t
-            else
-              # then upgrade it
-              placeholder.meth_type_map[t.meth_name] = 
-                  MethodListType.new([meth_type, t])
-            end
-          else
-            placeholder.meth_type_map[t.meth_name] = t
+    # This method modifies specified modules/classes at the very moment
+    # (instead of registering them for later).
+    def self.breakable(*mods)
+      mods.each do |mod|
+        case mod
+        when Array
+          self.breakable(*mod)
+        when Module, Class
+          MonitorInstaller.install_module_monitor(mod)
+          eigen_class = self.eigen_class(mod)
+          MonitorInstaller.install_module_monitor(eigen_class)
+          INSTALLED << mod << eigen_class
+        when String, Symbol
+          begin
+            # Get the actual module and install it right now
+            mod = eval("#{mod}", TOPLEVEL_BINDING)
+            self.breakable(mod) if mod
+          rescue NameError => e
+            RubyBreaker.error("#{mod} cannot be found.")
           end
+        else
+          RubyBreaker.error("You must specify a module/class or its name.")
         end
-        return t
       end
-   
     end
-   
-    # This method is triggered when Broken module is included. This just 
-    # extends BrokenEigen into the target module so "typesig" method can be
-    # called from the eigen level of the module. It also extends the eigen
-    # class of the target module so that "typesig" can work for class
-    # methods too.
-    def self.included(mod)
+  end
 
-      # Add to the list of broken modules
-      BROKEN << mod
+  # *DEPRECATED*: Use +RubyBreaker.run()+ to indicate the point of entry.
+  def self.monitor()
+  end
 
-      # Create if there is no type placeholder for this module yet
-      placeholder = TYPE_PLACEHOLDER_MAP[mod] 
-      if !placeholder 
-        placeholder = TypePlaceholder.new()
-        TYPE_PLACEHOLDER_MAP[mod] = placeholder
-      end
-      mod.extend(BrokenEigen)
+  # This method just redirects to Runtime's method.
+  def self.breakable(*mods)
+    Runtime.breakable(*mods)
+  end
 
-      # Support up to one eigen level to support class methods
-      eigen_class = Runtime.eigen_class(mod)
-      BROKEN << eigen_class
-      placeholder = TYPE_PLACEHOLDER_MAP[eigen_class] 
-      if !placeholder 
-        placeholder = TypePlaceholder.new()
-        TYPE_PLACEHOLDER_MAP[eigen_class] = placeholder
-      end
-      eigen_class.extend(BrokenEigen)
+  # *DEPRECATED*: Use +Runtime.breakable()+ or +RubyBreaker.run()+ method
+  #               instead.
+  module Breakable  
+    def self.included(mod)
+      Runtime::BREAKABLES << mod << Runtime.eigen_class(mod)
     end
-    
   end
 
+  # *DEPRECATED*: It has no effect.
+  module Broken 
+    def self.included(mod)
+      # Runtime.broken(mod)
+    end
+  end
 end

data/lib/rubybreaker/task.rb

@@ -0,0 +1,97 @@
+require "ostruct"
+require "optparse"
+require "rake/testtask"
+require "yaml"
+require "tempfile"
+
+module Rake
+
+  # This class can be used as a replacement for Rake::TestTask. It is a
+  # subclass of Rake::TestTask and maintains additional information for
+  # running RubyBreaker as a Rake test task. 
+  #
+  # For example, the following shows how to run RubyBreaker in a test task:
+  #
+  # desc "Run testtask test"
+  # Rake::RubyBreakerTestTask.new(:"testtask_test") do |t|
+  #   t.libs << "lib"
+  #   t.test_files = ["test/testtask/tc_testtask.rb"]
+  #   t.breakable = ["SampleClassA"]
+  # end
+  #
+  class RubyBreakerTestTask < Rake::TestTask
+
+    # List of Breakable modules/classes
+    attr_accessor :breakable
+
+    # RubyBreaker options
+    attr_accessor :rubybreaker_opts
+
+    # This overrides the testtask's constructor. In addition to the original
+    # behavior, it keeps track of RubyBreaker options and store them in a
+    # yaml file.
+    def initialize(taskname="", *args, &blk)
+
+      # Initialize extra instance variables
+      @rubybreaker_opts = []
+      @breakable = nil
+
+      # Call the original constructor first
+      super(taskname, *args, &blk)
+
+      # Parse the RubyBreaker options
+      case @rubybreaker_opts
+      when Array
+        opts = @rubybreaker_opts
+      when String
+        opts = @rubybreaker_opts.split(" ").select {|v| v != ""}
+      else
+        opts = []
+      end
+
+      # Construct the task configuration hash
+      config = {
+        name: taskname,
+        rubybreaker_opts: opts,
+        breakable: [], # Set doesn't work well with YAML; just use an array
+        test_files: @test_files,
+      }
+
+      # This allows a bulk declaration of Breakable modules/classes
+      @breakable.each { |b| config[:breakable] << b } if @breakable
+
+      # 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.
+      code_data = <<-EOS
+require "yaml"
+f = File.new(__FILE__, "r")
+while !(f.readline.match("^__END__.*$"))
+  # do nothing
+end
+data = f.read
+$__rubybreaker_task = YAML.load(data)
+__END__
+#{YAML.dump(config)}
+      EOS
+
+      tmp_path = ""
+      # Tests are run different processes, so we must export this
+      # information to an external yaml file.
+      f = Tempfile.new(["#{taskname}",".rb"]) 
+      tmp_path = f.path
+      f.write(code_data)
+      f.close()
+
+      # Inject the -r option to load this yaml file
+      if @ruby_opts && @ruby_opts.empty?
+        @ruby_opts << "-r" << tmp_path
+      else
+        @ruby_opts = ["-r", tmp_path]
+      end
+
+      return self
+    end
+
+  end
+
+end

data/lib/rubybreaker/test/rspec.rb

@@ -9,7 +9,7 @@ if defined?(RSpec)
 end
 
 def describe(*args,&blk)
-  RubyBreaker::Main.setup if defined?(RubyBreaker) 
+  RubyBreaker.run if defined?(RubyBreaker) 
   send(:"#{RUBYBREAKER_RSPEC_PREFIX}_describe", *args, &blk)
 end
 

data/lib/rubybreaker/test/testcase.rb

@@ -1,38 +1,23 @@
 #--
-# This file mimics the Ruby testing framework. This is provided so that
-# RubyBreaker can be used seamlessly with the traditional Ruby framework
-# (supposedly :) ).
+# This file overrides the test case behavior to work with RubyBreaker behind
+# the scene without requiring the user to modify the code.
 
-module RubyBreaker
+# Do this only if Test::Unit is defined
+if defined?(Test) && defined?(Test::Unit)
 
-  # This module overrides the normal behavior of Ruby Stdlib's TestCase
-  # class. 
-  module TestCase
+  # This class is patched to run RubyBreaker along with the test cases.
+  class Test::Unit::TestCase
 
-    def self.__rubybreaker_setup()
-      Main.setup()
-    end
+    # Save the original constructor method.
+    alias :__rubybreaker_initialize :initialize
 
-    def self.__rubybreaker_teardown()
-      # Main.output()
+    # This method overrides the original constructor to run RubyBreaker before
+    # calling the original constructor.
+    def initialize(*args, &blk)
+      RubyBreaker.run()
+      return send(:__rubybreaker_initialize, *args, &blk)
     end
 
-    def self.included(mod)
-
-      # hack to insert RubyBreaker's own setup and teardown methods
-      mod.module_eval <<-EOS
-
-      alias :__run :run
-
-      def run(*args,&blk)
-        RubyBreaker::TestCase.__rubybreaker_setup()
-        __run(*args,&blk)
-        RubyBreaker::TestCase.__rubybreaker_teardown()
-      end
-
-      EOS
-
-    end
   end
 end
 

data/lib/rubybreaker/type/type.rb

@@ -96,7 +96,7 @@ module RubyBreaker
     class SelfType < NominalType
 
       # This is a setter method for class variable mod. 
-      # NOTE: It is set every time Broken module is included.
+      # NOTE: It is set every time typesig() is called
       def self.set_self(mod)
         @@mod = mod
       end

data/lib/rubybreaker/typing/subtyping.rb

@@ -9,7 +9,7 @@
 # any constraint graph to resolve subtype relations. This is the main
 # difference between Rubydust and RubyBreaker. 
 #
-# If a module is not Broken but is Breakable (i.e., monitored), then it is
+# If a module is not broken but is breakable (i.e., monitored), then it is
 # treated as non-Broken. At the end of the execution, the module will be
 # Broken--i.e., its type information is now revealed. If the user wishes to
 # use the result of the analysis, this type information will be documented
@@ -57,6 +57,11 @@ module RubyBreaker
 
     private
 
+    # This method determins if the module/class has its corresponding 
+    def self.has_type_map?(mod)
+      return Runtime::TYPE_MAP[mod] != nil
+    end
+
     # Thie method checks if the module has all the methods specified in
     # meths array
     def self.module_has_methods?(mod, meths)
@@ -295,11 +300,11 @@ module RubyBreaker
     #
     def self.fusion_subtype_rel?(lhs,rhs)
       return false unless lhs.kind_of?(FusionType)
-      if lhs.mod.kind_of?(Broken)        
+      if self.has_type_map?(lhs.mod)
         if rhs.instance_of?(NominalType) # don't include self type
           if RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
             is_subtype = true
-          elsif rhs.mod.kind_of?(Broken)
+          elsif self.has_type_map?(rhs.mod)
             # then do a type check for each method
             lhs_meths = Inspect.inspect_all(lhs.mod)
             rhs_meths = Inspect.inspect_all(rhs.mod)
@@ -311,7 +316,7 @@ module RubyBreaker
         elsif rhs.instance_of?(FusionType)
           if RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
             is_subtype = true
-          elsif rhs.mod.kind_of?(Broken)
+          elsif self.has_type_map?(rhs.mod)
             # then do a type check for each method
             lhs_meths = Inspect.inspect_all(lhs.mod)
             rhs_meths = Inspect.inspect_meths(rhs.mod, lhs.meths.keys)
@@ -377,7 +382,7 @@ module RubyBreaker
         # If RHS is not broken, sorry no subtype relationship
         if RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
           is_subtype = true
-        elsif lhs.kind_of?(Broken) && rhs.kind_of?(Broken)
+        elsif self.has_type_map?(lhs.mod) && self.has_type_map?(rhs.mod)
           is_subtype = true
           lhs_methods = lhs.mod.instance_methods
           rhs.meth_names.each {|m| 

data/lib/rubybreaker/util.rb

@@ -27,7 +27,6 @@ module RubyBreaker
         lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
       end   
     end    
-
   end
 
 end