rubybreaker 0.0.1 → 0.0.2

data/lib/rubybreaker/runtime/inspector.rb

@@ -2,6 +2,7 @@
 # This file defines Inspector which finds the type placeholder for a
 # module.
 
+require_relative "util"
 require_relative "monitor"
 
 module RubyBreaker
@@ -18,16 +19,23 @@ module RubyBreaker
       # it returns nil
       def self.inspect_meth(mod, mname)
         mname = mname.to_sym 
-        if mod.included_modules.include?(Breakable)
+        if Breakable::TYPE_PLACEHOLDER_MAP.has_key?(mod)
           placeholder = Breakable::TYPE_PLACEHOLDER_MAP[mod]
-        elsif mod.included_modules.include?(Broken)
+        elsif Broken::TYPE_PLACEHOLDER_MAP.has_key?(mod)
           placeholder = Broken::TYPE_PLACEHOLDER_MAP[mod]
         else
           # TODO
         end
-        t = placeholder.inst_meths[mname] if placeholder
+        t = placeholder.meth_type_map[mname] if placeholder
         return t
       end
+
+      # This method inspects the module for the specified class method name.
+      # This is a shorthand for calling inspect_meth with the eigen class.
+      def self.inspect_class_meth(mod, mname)
+        eigen_class = Runtime.eigen_class(mod)
+        return self.inspect_meth(eigen_class, mname)
+      end
       
       # Similar to inspect_meth but returns a hash of (mname, mtype) pairs.
       def self.inspect_meths(mod, mnames)
@@ -43,10 +51,11 @@ module RubyBreaker
       def self.inspect_all(mod)
         mtypes = {}
         mm = Breakable::TYPE_PLACEHOLDER_MAP[mod]
-        # mm = MonitorUtils.get_module_monitor(mod)
-        mm.inst_meths.each_pair {|im,mtype|
-          mtypes[im] = mtype if mtype 
-        }
+        if mm
+          mm.meth_type_map.each_pair {|im,mtype|
+            mtypes[im] = mtype if mtype 
+          }
+        end
         return mtypes
       end 
       

data/lib/rubybreaker/runtime/monitor.rb

@@ -5,6 +5,7 @@
 # functions for later use (after runtime).
 
 dir = File.dirname(__FILE__) 
+require_relative "util"
 require_relative "type_placeholder"
 require_relative "../context"
 require_relative "../debug"
@@ -129,21 +130,16 @@ module RubyBreaker
         end
 
         is_obj_mod = (obj.class == Class or obj.class == Module)
-
-        # from here, do more work for module monitoring
-        mod = obj.class 
-
-        # TODO:
-        meta = false
+        mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
 
         # mm = get_module_monitor(mod) unless is_obj_mod
-        mm = Breakable::MONITOR_MAP[mod] if !is_obj_mod
+        mm = Breakable::MONITOR_MAP[mod] 
 
         # There is something wrong if there isn't a module monitor
         # associated with the call.
-        # raise Exception if mm == nil || !mm.inst_meths.include?(meth_name)
+        # raise Exception if mm == nil || !mm.meth_type_map.include?(meth_name)
 
-        meth_info = MethodInfo.new(meta, meth_name, args, blk, nil)
+        meth_info = MethodInfo.new(meth_name, args, blk, nil)
 
         mm.monitor_before_method(obj, meth_info)
 
@@ -161,6 +157,8 @@ module RubyBreaker
 
         meth_info.ret = retval
         mm.monitor_after_method(obj, meth_info)
+        retval = meth_info.ret  # Return value may have been altered by the
+                                # after_method monitoring code
 
         # things are done in this context. pop it off.
         CONTEXT.pop()
@@ -196,7 +194,7 @@ module RubyBreaker
 
       # renames the method in essence; this method also "installs" the
       # module monitor for the class
-      def self.rename_meth(recv,meth_name)
+      def self.rename_meth(recv, meth_name)
         alt_meth_name = MonitorUtils.get_alt_meth_name(meth_name)
         recv.module_eval("alias :\"#{alt_meth_name}\" :\"#{meth_name}\"")
         Debug.msg("Adding alternate method for #{meth_name}")
@@ -210,15 +208,13 @@ module RubyBreaker
         EOF
       end
 
-      # Installs an module (class) monitor to the object.
-      def self.install_module_monitor(mod,infer=false)
+      # Installs an module (class) monitor to the object. 
+      def self.install_module_monitor(mod)
         Debug.short_msg("Installing module monitor for #{mod}")
-        if infer
-          Breakable::MONITOR_MAP[mod] = Monitor.new(mod, DEFAULT_TYPE_SYSTEM)
-          Breakable::TYPE_PLACEHOLDER_MAP[mod] = TypePlaceholder.new
-        end
-        inst_meths = []
-        meths = mod.instance_methods(false)
+        Breakable::MONITOR_MAP[mod] = Monitor.new(mod, DEFAULT_TYPE_SYSTEM)
+        Breakable::TYPE_PLACEHOLDER_MAP[mod] = TypePlaceholder.new
+        meth_type_map = []
+        meths = mod.instance_methods(false)  
         meths.each do |m| 
           self.rename_meth(mod,m) 
         end

data/lib/rubybreaker/runtime/object_wrapper.rb

@@ -34,13 +34,17 @@ module RubyBreaker
       end
 
       #--
-      # The following code will generate "serious problem" warning. But it's
-      # ok. This meta programming code re-defines BasicObject's methods to
-      # redirect to the actual object.
+      # The following code generates the "serious problem" warning which is
+      # suppressed by the hack using $VERBOSE. This is ok.  This meta
+      # programming code block re-defines BasicObject's methods to redirect
+      # to the actual object.
       [:"!", :"!=", :"==", :"equal?", :"eql?", :"__id__", :"object_id",
         :"send", :"__send__", :"instance_eval", 
         :"instance_exec"].each do |meth|
 
+        orig_verbose = $VERBOSE
+        $VERBOSE = nil
+
         eval <<-EOS
 
       def #{meth}(*args,&blk)
@@ -49,6 +53,8 @@ module RubyBreaker
 
         EOS
 
+        $VERBOSE = orig_verbose
+
       end
       
       # Only behave differently if it's looking for +WRAPPED_INDICATOR+

data/lib/rubybreaker/runtime/overrides.rb

@@ -1,6 +1,13 @@
 #--
 # This file contains methods that need to override the existing ones to
-# accommodate the object wrapper.
+# accommodate the object wrapper. The main issue arises when a wrapped
+# object is compared against a non-wrapped object in either direction. Going
+# from a wrapped object, this issue is resolved by overriding the comparison
+# operators, but going from a non-wrapped object, the override has to
+# happen on the non-wrapped side. This file is for those overrides.
+#
+# XXX: THIS FILE NEEDS A LOT OF WORK!!! 
+#
 
 require_relative "object_wrapper"
 
@@ -10,25 +17,61 @@ module RubyBreaker
 
     # This constant holds the string used internally by RubyBreaker to
     # indicate overridden methods.
-    OVERRIDE_PREFIX = "__rubybreaker_"
+    OVERRIDE_PREFIX = "__rubybreaker"
 
   end
 
 end
 
+# TODO: More IO related stuff need to be overriden!
+[Kernel, IO].each do |mod|
 
-class Numeric
+  [:"puts", :"putc", :"printf", :print].each do |meth_name|
 
-  [:"==", :equal?, :eql?].each do |m|
+    mod.module_eval <<-EOS
 
-    eval <<-EOS
+    alias :"#{RubyBreaker::Runtime::OVERRIDE_PREFIX}_#{mod.object_id}_#{meth_name}" :"#{meth_name}"
 
-  alias :"#{RubyBreaker::Runtime::OVERRIDE_PREFIX}#{m}" :"#{m}"
-  def #{m}(other)
+    EOS
+
+    mod.module_eval <<-EOS
+
+    def #{meth_name}(*args)
+      args = args.map do |arg|
+        if arg.respond_to?(RubyBreaker::Runtime::WRAPPED_INDICATOR)
+          arg.__rubybreaker_obj
+        else
+          arg
+        end
+      end
+      send(:"#{RubyBreaker::Runtime::OVERRIDE_PREFIX}_#{mod.object_id}_#{meth_name}",*args)
+    end
+
+    EOS
+  
+  end
+
+end
+
+# TODO: add more modules here as necessary!
+[Object, Numeric, String, Symbol, Enumerable, Array, Hash].each do |mod| 
+
+  [:"==", :equal?, :eql?].each do |meth_name|
+
+    # Create a unique alias name for each module. (It causes some issue when
+    # not done this way.)
+    alias_name = "RubyBreaker::Runtime::OVERRIDE_PREFIX_#{mod.object_id}" +
+                 "_#{meth_name}"
+
+    mod.module_eval <<-EOS
+
+  alias :"#{alias_name}" :"#{meth_name}"
+
+  def #{meth_name}(other)
     if other.respond_to?(RubyBreaker::Runtime::WRAPPED_INDICATOR)
       other = other.__rubybreaker_obj
     end
-    return self.send(:"#{RubyBreaker::Runtime::OVERRIDE_PREFIX}#{m}", other)
+    return self.send(:"#{alias_name}",other)
   end
 
     EOS

data/lib/rubybreaker/runtime/pluggable.rb

@@ -11,14 +11,12 @@ module RubyBreaker
     # by Pluggable and Monitor
     class MethodInfo
 
-      attr_accessor :meta 
       attr_accessor :meth_name
       attr_accessor :args
       attr_accessor :blk
       attr_accessor :ret
 
-      def initialize(meta, meth_name, args, blk, ret)
-        @meta = meta
+      def initialize(meth_name, args, blk, ret)
         @meth_name = meth_name
         @args = args
         @blk = blk

data/lib/rubybreaker/runtime/type_placeholder.rb

@@ -10,14 +10,10 @@ module RubyBreaker
     class TypePlaceholder
 
       # This accessor sets/gets instance method map
-      attr_accessor :inst_meths  # method name => method type
-
-      # This accessor sets/gets module method map (XXX: not used)
-      attr_accessor :mod_meths
+      attr_accessor :meth_type_map  # method name => method type
 
       def initialize()
-        @inst_meths = {}
-        @mod_meths = {}
+        @meth_type_map = {}
       end
 
     end

data/lib/rubybreaker/runtime/type_system.rb

@@ -5,6 +5,7 @@
 # this type system is to give a readable type signature to every method in
 # designated modules and classes.
 
+require_relative "util"
 require_relative "object_wrapper"
 require_relative "type_placeholder"
 require_relative "../type"
@@ -104,26 +105,36 @@ module RubyBreaker
       # the method type to a method list type.
       #
       # obj:: the receive of the method call
-      # inst_meths:: a hash object that maps method names to method types 
+      # meth_type_map:: a hash object that maps method names to method types 
       # meth_name:: the name of the method being invoked
       # retval:: the return value of the original method call
       # args:: the arguments
       # blk:: the block argument
       #
-      def lub(obj, inst_meths, meth_name, retval, *args, &blk)
+      def lub(obj, meth_type_map, meth_name, retval, *args, &blk)
         
-        exist_meth_type = inst_meths[meth_name.to_sym] 
+        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))
+        arity = meth_obj.arity
+
         # Construct the newly observed method type first
-        new_meth_type = MethodType.new(meth_name)
-        args.each {|arg|
+        new_meth_type = MethodType.new(meth_name,[])
+        args.each_with_index do |arg,idx|
           if is_object_wrapped?(arg)
             arg_type = arg.__rubybreaker_type
           else
             arg_type = NominalType.new(arg.class)
           end
+          # Check if the last argument should be a variable length argument
+          if arity < 0 && (idx + 1 == arity.abs)
+            new_meth_type.arg_types << VarLengthType.new(arg_type)
+            break
+          end
           new_meth_type.arg_types << arg_type
-        }
+        end
+
         if (obj == retval)
           # the return value is same as the message receiver. This means the
           # return value has the self type.
@@ -133,7 +144,7 @@ module RubyBreaker
           # Otherwise, construct a nominal type.
           ret_type = NominalType.new(retval.class)
         end
-        new_meth_type.ret_type  = ret_type
+        new_meth_type.ret_type = ret_type
 
         resolved = false
         if exist_meth_type.instance_of?(MethodListType)
@@ -147,7 +158,7 @@ module RubyBreaker
             # Could not resolve the types, so promote the method type to a
             # method list type
             exist_meth_type = MethodListType.new([exist_meth_type])
-            inst_meths[meth_name.to_sym] = exist_meth_type
+            meth_type_map[meth_name.to_sym] = exist_meth_type
           end
         end 
         if !resolved
@@ -161,8 +172,10 @@ module RubyBreaker
       # each argument with the object wrapper.
       def before_method(obj, meth_info)
 
-        mod = obj.class
-        inst_meths = Breakable::TYPE_PLACEHOLDER_MAP[mod].inst_meths
+        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
 
         # Let's take things out of the MethodInfo object
         meth_name = meth_info.meth_name
@@ -181,7 +194,7 @@ module RubyBreaker
 
         Debug.msg("In module monitor_before #{meth_name}")
         
-        meth_type = inst_meths[meth_name]
+        meth_type = meth_type_map[meth_name]
         
         if meth_type
           # This means the method type has been created previously.
@@ -193,10 +206,22 @@ module RubyBreaker
           # No method type has been created for this method yet. Create a
           # blank method type (where each argument type, block type, and
           # return type are all nil).
-          arg_types = args.map {|arg| nil }
-          blk_type = blk ? BlockType.new(Array.new(blk.arity), nil, nil) : nil
+          #
+          # First, use the orignal method's arity to find out # of
+          # arguments. 
+          meth_obj = obj.method(MonitorUtils.get_alt_meth_name(meth_name))
+          arity = meth_obj.arity
+          arg_types = [nil] * meth_obj.arity.abs 
+          if blk
+            # Do the same for the block too if there is one
+            blk_arity = blk.arity
+            blk_arg_types = [nil] * blk_artiy.abs
+            blk_type = BlockType.new(blk_arg_types, nil, nil)
+          else
+            blk_type = nil
+          end
           meth_type = MethodType.new(meth_name, arg_types, blk_type, nil)
-          inst_meths[meth_name] = meth_type
+          meth_type_map[meth_name] = meth_type
         end
 
         meth_info.args = args
@@ -206,7 +231,10 @@ module RubyBreaker
       # This method occurs after every "monitored" method call. It updates
       # the type information.
       def after_method(obj, meth_info)
-        mod = obj.class
+
+        is_obj_mod = (obj.class == Class or obj.class == Module)
+        mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
+
         # Take things out
         meth_name = meth_info.meth_name
         retval = meth_info.ret
@@ -215,10 +243,18 @@ module RubyBreaker
 
         Debug.msg("In module monitor_after #{meth_name}")
 
-        inst_meths = Breakable::TYPE_PLACEHOLDER_MAP[mod].inst_meths
+        meth_type_map = Breakable::TYPE_PLACEHOLDER_MAP[mod].meth_type_map
 
         # Compute the least upper bound
-        lub(obj, inst_meths,meth_name,retval,*args,&blk)
+        lub(obj, meth_type_map,meth_name,retval,*args,&blk)
+
+        if obj == retval  
+          # It is possible that the method receiver is a wrapped object if
+          # it is an argument to a method in the current call stack. So this
+          # check is to return the wrapped object and not the stripped off
+          # version. (Remember, == is overridden for the wrapped object.)
+          meth_info.ret = obj
+        end
 
       end
 

data/lib/rubybreaker/runtime/typesig_parser.rb

@@ -21,6 +21,7 @@ module RubyBreaker
       # lines in the signature, it will look at each line and construct a
       # MethodListType to represent the intersection type.
       def self.parse(str)
+
         meth_types = []
         
         # Get caller information and set the global location 

data/lib/rubybreaker/runtime/util.rb

@@ -0,0 +1,18 @@
+#-
+# This file contains utility functions that are useful for the Runtime
+# Library.
+
+module RubyBreaker
+
+  module Runtime
+
+    private
+
+    # This returns the eigen class of the given module.
+    def self.eigen_class(mod)
+      return mod.module_eval("class << self; self end")
+    end
+
+  end
+
+end

data/lib/rubybreaker/runtime.rb

@@ -10,6 +10,18 @@ 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.
+
+  # This array lists modules/classes that will be monitored.
+  BREAKABLE = []
+
+  # This array lists "broken" classes--i.e., with type signatures
+  BROKEN = []
+
   # 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
@@ -21,10 +33,11 @@ module RubyBreaker
     TYPE_PLACEHOLDER_MAP = {} # module => type_placeholder
     MONITOR_MAP = {}          # module => monitor
 
-    # when this module is included, simply keep track of this module so we
-    # can start monitoring
+    # 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)
     end
 
   end
@@ -37,8 +50,9 @@ module RubyBreaker
 
     TYPE_PLACEHOLDER_MAP = {} # module => type_placeholder
  
-    # This module will be "extended" to the meta class of the class that 
-    # includes Broken module. This allows the meta class to call 'typesig' 
+    #-
+    # 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:
@@ -49,28 +63,32 @@ module RubyBreaker
     #     def foo(x) ... end
     #   end
     #
-    module BrokenMeta
+    module BrokenEigen
 
       include TypeDefs
       include Runtime
 
-      # This method can be used at the meta level of the target module to
+      # 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.inst_meths[t.meth_name]
+          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.inst_meths[t.meth_name] = MethodListType.new([meth_type, t])
+              placeholder.meth_type_map[t.meth_name] = MethodListType.new([meth_type, t])
             end
           else
-            placeholder.inst_meths[t.meth_name] = t
+            placeholder.meth_type_map[t.meth_name] = t
           end
         end
         return t
@@ -79,23 +97,32 @@ module RubyBreaker
     end
    
     # This method is triggered when Broken module is included. This just 
-    # extends BrokenMeta into the target module so "typesig" method can be
-    # called from the meta level of the module.
+    # 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)
 
       # Add to the list of broken modules
       BROKEN << mod
 
-      # This MUST BE set for self type to work in type signatures
-      SelfType.set_self(mod) 
-
       # 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(BrokenMeta)
+      mod.extend(BrokenEigen)
+
+      # 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)
     end
     
   end

data/lib/rubybreaker/type/type_comparer.rb

@@ -53,7 +53,7 @@ module RubyBreaker
       return is_equal
     end
 
-		# This method determines if the type exists in the given type list.
+    # This method determines if the type exists in the given type list.
     def self.type_in_types?(t, types)
       exist = false
       types.each do |t2|
@@ -67,8 +67,8 @@ module RubyBreaker
     
     # This method compares two OR or MethodListType. The order of inner
     # types do not matter.
-		#
-		# XXX: Should the order not matter really?
+    #
+    # XXX: Should the order not matter really?
     def self.or_compare(lhs,rhs)
       is_equal = false
       if lhs.class == rhs.class && lhs.types.size == rhs.types.size
@@ -83,7 +83,7 @@ module RubyBreaker
       return is_equal
     end
 
-		# This method compares a method list to another method list.
+    # This method compares a method list to another method list.
     def self.meth_list_compare(lhs, rhs)
       return self.or_compare(lhs, rhs)
     end
@@ -99,8 +99,8 @@ module RubyBreaker
         is_equal = false
       elsif lhs.instance_of?(NominalType)
         is_equal = (lhs.mod == rhs.mod)
-			elsif lhs.instance_of?(SelfType)
-				is_equal = rhs.instance_of?(SelfType)
+      elsif lhs.instance_of?(SelfType)
+        is_equal = rhs.instance_of?(SelfType)
       elsif lhs.instance_of?(DuckType)
         is_equal = duck_compare(lhs,rhs)
       elsif lhs.instance_of?(FusionType)
@@ -120,11 +120,11 @@ module RubyBreaker
       elsif lhs.instance_of?(OrType)
         is_equal = self.or_compare(lhs,rhs)
       elsif lhs.instance_of?(VarLengthType)
-				is_equal = rhs.instance_of?(VarLengthType) && 
-					         self.compare(lhs.type, rhs.type)
+        is_equal = rhs.instance_of?(VarLengthType) && 
+                   self.compare(lhs.type, rhs.type)
       elsif lhs.instance_of?(OptionalType)
-				is_equal = rhs.instance_of?(OptionalType) &&
-									 self.compare(lhs.type, rhs.type)
+        is_equal = rhs.instance_of?(OptionalType) &&
+                   self.compare(lhs.type, rhs.type)
       else
         is_equal = lhs.class == rhs.class
       end