rubybreaker 0.0.8 → 0.0.9

data/NEWS

@@ -1,3 +1,9 @@
+# VERSION 0.0.9
+* More critical bug fixes
+
+# VERSION 0.0.8
+* Bug fixes
+
 # VERSION 0.0.7
 * Early dynamic type check is implemented.
 

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/bin/rubybreaker

@@ -9,10 +9,10 @@ module RubyBreaker
     exit(1)
   end
 
-  # This method prepares shell mode execution of RubyBreaker.
+  # This method prepares the command mode execution of RubyBreaker.
   def self.main()
     RubyBreaker.setup_logger()
-    RubyBreaker.verbose("Running RubyBreaker in shell mode")
+    RubyBreaker.verbose("Running RubyBreaker in the command mode")
 
     # parse the command-line arguments
     OPTION_PARSER.parse!   
@@ -60,7 +60,7 @@ module RubyBreaker
       self.verbose("Done importing #{lib}")
     end
 
-    # Now, RubyBreaker shell mode will run this
+    # Runs the main library code at this point
     RubyBreaker.run()
 
     # Run the program file!

data/lib/rubybreaker.rb

@@ -133,18 +133,22 @@ module RubyBreaker
     if fname && OPTIONS[:save_output]
       # Check if the file already exists--that is, if it was used for input
       io_exist = File.exists?(fname)
-      RubyBreaker.verbose("Saving it to #{fname}")
-      # Append the result to the input file (or create a new file)
-      fmode = OPTIONS[:append] ? "a" : "w"
-      open(fname, fmode) do |f|
-        # When append, do not write the header
-        unless OPTIONS[:append] 
-          f.puts "# This file is auto-generated by RubyBreaker" 
+      if File.writable?(fname)
+        RubyBreaker.verbose("Saving it to #{fname}")
+        # Append the result to the input file (or create a new file)
+        fmode = OPTIONS[:append] ? "a" : "w"
+        open(fname, fmode) do |f|
+          # When append, do not write the header
+          unless OPTIONS[:append] 
+            f.puts "# This file is auto-generated by RubyBreaker" 
+          end
+          # But time stamp always
+          f.puts "# Last modified: #{Time.now}"
+          f.puts "require \"rubybreaker\"" unless OPTIONS[:append] 
+          f.print code
         end
-        # But time stamp always
-        f.puts "# Last modified: #{Time.now}"
-        f.puts "require \"rubybreaker\"" unless OPTIONS[:append] 
-        f.print code
+      else
+        RubyBreaker.verbose("Cannot write to #{fname}.")
       end
     end
 

data/lib/rubybreaker/doc/rdoc.rb

@@ -5,7 +5,7 @@ module RubyBreaker
 
   # This module has functionalities that are necessary for supporting RDoc
   # output
-  module RDocSupport
+  module RDocSupport #:nodoc:
 
     include TypeDefs
 

data/lib/rubybreaker/runtime/monitor.rb

@@ -94,14 +94,13 @@ module RubyBreaker
             mm.check_before_method(obj, meth_info)
           end
         rescue ::Exception => e
+          RubyBreaker.log("Exception #{e.class} has been raised.", :debug, CONTEXT)
           # Trap it, turn on the global monitor and then re-raise the
           # exception
           GLOBAL_MONITOR_SWITCH.turn_on()
           raise e
         end
 
-        RubyBreaker.log("break_before_method ended")
-
         # we are going to turn the switch back on
         GLOBAL_MONITOR_SWITCH.turn_on()
 
@@ -109,9 +108,10 @@ module RubyBreaker
         retval = obj.send(stub_meth_name.to_sym, *meth_info.args,
                           &meth_info.blk)
 
-        # turn it off
+        # turn the switch off again
         GLOBAL_MONITOR_SWITCH.turn_off()
 
+        # Remember the return value in the method info object.
         meth_info.ret = retval
 
         begin
@@ -124,6 +124,7 @@ module RubyBreaker
         rescue ::Exception => e
           # Trap it, turn on the global monitor and then re-raise the
           # exception
+          RubyBreaker.log("Exception #{e.class} has been raised.", :debug, CONTEXT)
           GLOBAL_MONITOR_SWITCH.turn_on()
           raise e
         end
@@ -143,7 +144,7 @@ module RubyBreaker
 
       # This method returns the alternative (renamed) method name
       def self.get_alt_meth_name(meth_name)
-        return "__#{meth_name}"
+        return "__rubybreaker_#{meth_name}"
       end
 
       # This method returns the original method name
@@ -237,11 +238,11 @@ module RubyBreaker
       # Installs an module (class) monitor to the object. 
       def self.install_monitor(monitor_type, mod)
 
-        RubyBreaker.log("Installing module monitor for #{mod}")
+        RubyBreaker.log("Installing #{monitor_type} monitor for #{mod} started.")
 
         # Do not re-install monitor if already done so.
         if MONITOR_MAP[mod] 
-          RubyBreaker.log("Skip #{mod} as it has a monitor installed.")
+          RubyBreaker.log("#{mod} already has a monitor installed.")
           return
         end
 
@@ -266,6 +267,7 @@ module RubyBreaker
           end
         end
 
+        RubyBreaker.log("Installing #{monitor_type} monitor for #{mod} ended.")
       end
 
     end

data/lib/rubybreaker/runtime/object_wrapper.rb

@@ -35,13 +35,25 @@ module RubyBreaker
         return @__rubybreaker_type
       end
 
+      # This method computes the wrap level of any given wrapped object. In
+      # theory, this should always be 1. 
+      #
+      # Used for internal debugging purpose only
+      def __rubybreaker_wrap_level() #:nodoc:
+        val = 1
+        if @__rubybreaker_obj.respond_to?(WRAPPED_INDICATOR)
+          val += @__rubybreaker_obj.__rubybreaker_wrap_level
+        end
+        return val
+      end
+
       #--
       # 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", 
+        :"send", :"__send__", :"instance_eval", :class,
         :"instance_exec"].each do |meth|
 
         orig_verbose = $VERBOSE
@@ -65,14 +77,20 @@ module RubyBreaker
         return true if mname.to_sym == WRAPPED_INDICATOR
         return @__rubybreaker_obj.respond_to?(mname)
       end
+
+      # # Keep track of methods that MUST NOT take wrapped arguments.
+      # WRAP_BLACKLIST = {
+      #   ::Array => [:[], :[]=],
+      #   ::Hash => [:[], :[]=],
+      # }
       
       # This method missing method redirects all other method calls.
       def method_missing(mname,*args,&blk)
-        ::RubyBreaker.log("Method_missing for #{mname}")
         if GLOBAL_MONITOR_SWITCH.switch
 
           # Be safe and turn the switch off
           GLOBAL_MONITOR_SWITCH.turn_off
+          ::RubyBreaker.log("Object wrapper method_missing for #{mname} started")
 
           # Must handle send method specially (do not track them)
           if [:"__send__", :send].include?(mname)
@@ -88,16 +106,18 @@ module RubyBreaker
           is_obj_mod = (obj.class == ::Class or obj.class == ::Module)
           mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
 
-          # Monitor map doesn't exist MEANS it's not being monitored.
-          unless MONITOR_MAP[mod]
-            args.map! do |arg|
-              if arg.respond_to?(WRAPPED_INDICATOR)
-                arg.__rubybreaker_obj
-              else
-                arg
-              end
-            end
-          end
+          # # There are certain methods that should not take wrapped
+          # # argument(s) whatsoever. Use WRAP_BLACKLIST for these.
+          # if !MONITOR_MAP[mod] && WRAP_BLACKLIST[mod] &&
+          #    WRAP_BLACKLIST[mod].include?(mname)
+          #   args.map! do |arg|
+          #     if arg.respond_to?(WRAPPED_INDICATOR)
+          #       arg.__rubybreaker_obj
+          #     else
+          #       arg
+          #     end
+          #   end
+          # end
 
           # Turn on the global switch again
           GLOBAL_MONITOR_SWITCH.turn_on
@@ -105,13 +125,15 @@ module RubyBreaker
           # And call the original method 
           retval =  @__rubybreaker_obj.send(mname, *args, &blk)
 
-          # No need to wrap the object again...if it's wrapped already
-          unless retval.respond_to?(WRAPPED_INDICATOR)
-            retval = ObjectWrapper.new(retval)
-          end
+          # # No need to wrap the object again...if it's wrapped already
+          # unless retval.respond_to?(WRAPPED_INDICATOR)
+          #   retval = ObjectWrapper.new(retval)
+          # end
         else
+          ::RubyBreaker.log("Object wrapper method_missing for #{mname} started")
           retval = @__rubybreaker_obj.send(mname, *args, &blk)
         end
+        ::RubyBreaker.log("Object wrapper method_missing for #{mname} ended")
         return retval
       end
     end

data/lib/rubybreaker/runtime/overrides.rb

@@ -19,19 +19,31 @@ module RubyBreaker
     # indicate overridden methods.
     OVERRIDE_PREFIX = "__rubybreaker"
 
-    # Prohibit these module/class+method from being overriden
+    # Prohibit these module/class+method from being overriden. 
     BLACKLIST = {
       String => [:to_s, :<<, :concat, :gsub],
     }
 
+    # Allow certain methods of these classes/modules to be overrriden. That
+    # is, they will take unwrapped arguments whatsoever.
+    WHITELIST = {
+      Kernel => [:puts, :putc, :gets, :print, :printf, :raise],
+      IO => [:getc, :gets, :putc, :puts, :print, :printf, 
+             :readlines, :readline, :read],
+      Object     => [:"==", :equal?, :eql?, :"!="], 
+      Enumerable => [:"==", :equal?, :eql?, :"!="], 
+      Array      => [:"==", :equal?, :eql?, :"!=", :[], :[]=], 
+      Hash       => [:"==", :equal?, :eql?, :"!=", :[], :[]=],
+    }
+
   end
 
 end
 
 # TODO: More IO related stuff need to be overriden!
-[Kernel, IO].each do |mod|
+RubyBreaker::Runtime::WHITELIST.each_pair do |mod, mlist|
 
-  [:"puts", :"putc", :"printf", :print].each do |meth_name|
+  mlist.each do |meth_name|
 
     mod.module_eval <<-EOS
 
@@ -58,7 +70,7 @@ end
 
 end
 
-[Symbol, Numeric, Fixnum, Float, Integer, Bignum, String].each do |mod|
+[Exception, StandardError, ArgumentError, Symbol, Numeric, Fixnum, Float, Integer, Bignum, String].each do |mod|
   mod.instance_methods(false).each do |meth_name|
     black_list = RubyBreaker::Runtime::BLACKLIST
     next if black_list[mod] && black_list[mod].include?(meth_name)
@@ -83,32 +95,32 @@ end
   end
 end
 
-# TODO: add more modules here as necessary!
-[Object, 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(:"#{alias_name}",other)
-  end
-
-    EOS
-
-  end
-
-end
+# # TODO: add more modules here as necessary!
+# [Object, 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(:"#{alias_name}",other)
+#   end
+# 
+#     EOS
+# 
+#   end
+# 
+# end
 
 
 

data/lib/rubybreaker/runtime/type_system.rb

@@ -41,21 +41,31 @@ module RubyBreaker
         # most restrictive for the given test cases. 
         arg_types = []
 
+        # Resolve the argument types first.
         exist_meth_type.arg_types.each_with_index do |exist_arg_type, i|
           arg_type = nil
           new_arg_type = new_meth_type.arg_types[i]
           if !exist_arg_type 
-            # nil means there hasn't been any type observed
+            # nil means there hasn't been any type observed so use the new
+            # argument type as "resolved".
             arg_type = new_arg_type
           elsif new_arg_type.subtype_of?(exist_arg_type) 
+            # Pick the subtype argument since we are resolving in
+            # contra-variance
+            arg_type = new_arg_type
+          elsif exist_arg_type.subtype_of?(new_arg_type)
+            # Pick the subtype argument since we are resolving in
+            # contra-variance
             arg_type = exist_arg_type
-          elsif !exist_arg_type.subtype_of?(new_arg_type)
-            # No subtype relation between them, so OR them
+          else
+            # No subtype relation between them, so OR them.
             arg_type = OrType.new([new_arg_type, exist_arg_type])
           end
           arg_types << arg_type
         end
 
+        # Now, resolve the return type
+
         new_ret_type = new_meth_type.ret_type
         exist_ret_type = exist_meth_type.ret_type
 
@@ -63,10 +73,12 @@ module RubyBreaker
           ret_type = new_ret_type
           resolved = true
         elsif exist_ret_type.subtype_of?(new_ret_type) 
-          ret_type = exist_ret_type
+          # Co-variance
+          ret_type = new_ret_type
           resolved = true
         elsif new_ret_type.subtype_of?(exist_ret_type) 
-          ret_type = new_ret_type
+          # Co-variance
+          ret_type = exist_ret_type
           resolved = true
         else
           resolved = false
@@ -213,6 +225,8 @@ module RubyBreaker
         args = meth_info.args
         # blk = meth_info.blk
 
+        RubyBreaker.log("check_before_method #{mod}##{meth_name} started")
+
         # Get the registered method type for this method
         meth_type = meth_type_map[meth_name]
 
@@ -263,6 +277,7 @@ module RubyBreaker
           end
         end
 
+        RubyBreaker.log("check_before_method #{mod}##{meth_name} ended")
       end
 
       # This method is invoked after the original method is executed.
@@ -270,13 +285,16 @@ module RubyBreaker
         is_obj_mod = (obj.class == Class or obj.class == Module)
         mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
 
+        # Get the method type map for the module/class from the global map.
         meth_type_map = TYPE_MAP[mod]
-        return unless meth_type_map
+        return unless meth_type_map 
 
         # Let's take things out of the MethodInfo object
         meth_name = meth_info.meth_name
         ret = meth_info.ret
 
+        RubyBreaker.log("check_after_method #{mod}##{meth_name} started")
+
         # Get the registered method type for this method
         meth_type = meth_type_map[meth_name]
 
@@ -286,6 +304,8 @@ module RubyBreaker
                 " return value does not have type #{ret_type.unparse()}."
           raise Errors::ReturnTypeError.new(msg)
         end
+
+        RubyBreaker.log("check_after_method #{mod}##{meth_name} started")
       end
       
       # This method occurs before every call to a "monitored" method in a
@@ -298,30 +318,37 @@ 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 = TYPE_MAP[mod]
-
         # 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
 
+        RubyBreaker.log("break_before_method #{mod}##{meth_name} started")
+        
         args = args.map do |arg|
           if arg == nil || arg.kind_of?(TrueClass) || arg.kind_of?(FalseClass) 
             # XXX: would overrides resolve this issue?
             arg 
+          elsif arg.respond_to?(WRAPPED_INDICATOR)
+            # Don't need to wrap an object that is already wrapped
+            arg
           else
             ObjectWrapper.new(arg)
           end
         end
 
-        RubyBreaker.log("In module monitor_before #{meth_name}")
-        
+        # Using this module object, retrieve the method type map which
+        # maps method names to method types.
+        meth_type_map = TYPE_MAP[mod]
+
+        # Using the method name, get the type of this method from the map.
         meth_type = meth_type_map[meth_name]
         
         if meth_type
           # This means the method type has been created previously.
-          unless (blk == nil && meth_type.blk_type == nil) &&
+          unless !meth_type.instance_of?(MethodType) ||
+                 (blk == nil && meth_type.blk_type == nil) &&
                  (!blk || blk.arity == meth_type.blk_type.arg_types.length)
             raise Errors::TypeError.new("Block usage is inconsistent")
           end
@@ -349,6 +376,8 @@ module RubyBreaker
 
         meth_info.args = args
 
+        RubyBreaker.log("break_before_method #{mod}##{meth_name} ended")
+
       end
 
       # This method occurs after every call to a "monitored" method call of
@@ -359,16 +388,16 @@ module RubyBreaker
         is_obj_mod = (obj.class == Class or obj.class == Module)
         mod = is_obj_mod ? Runtime.eigen_class(obj) : obj.class
 
-        # Take things out
+        # Take things out of the method info object
         meth_name = meth_info.meth_name
         retval = meth_info.ret
         args = meth_info.args
         blk = meth_info.blk
 
-        RubyBreaker.log("In module monitor_after #{meth_name}")
+        RubyBreaker.log("break_after_method #{mod}##{meth_name} started")
 
         # Compute the least upper bound
-        lub(obj, TYPE_MAP[mod],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
@@ -378,6 +407,8 @@ module RubyBreaker
           meth_info.ret = obj
         end
 
+        RubyBreaker.log("break_after_method #{mod}##{meth_name} ended")
+
       end
 
     end