rubybreaker 0.0.1 → 0.0.2

data/lib/rubybreaker/type/type_grammar.treetop

@@ -20,8 +20,8 @@ grammar TypeGrammar
         ret = ret_type.value
         pos = RubyBreaker::Position.get()
         pos.col = meth_name.interval.first
-		    return RubyBreaker::MethodType.new(mname,args,blk,ret,pos)
-		  end
+        return RubyBreaker::MethodType.new(mname,args,blk,ret,pos)
+      end
     }
   end
   
@@ -216,15 +216,15 @@ grammar TypeGrammar
     nil_type / any_type1 / self_type / nominal_type
   end
 
-	rule self_type
-		'self' {
-			def value
-				pos = RubyBreaker::Position.get()
-				pos.col = interval.first
-				return RubyBreaker::SelfType.new(pos)
-			end
-		}
-	end
+  rule self_type
+    'self' {
+      def value
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::SelfType.new(pos)
+      end
+    }
+  end
 
   rule nominal_type
     [a-z_]+ {
@@ -264,20 +264,29 @@ grammar TypeGrammar
   end
   
   rule meth_name
-		nominal_meth_name / sym_meth_name
+    deprecated_meth_name / normal_meth_name
   end
 
-	rule sym_meth_name
-		# Be careful about the order. Remember, it finds a match first
-		'===' / '<=>' / '[]=' / 
-		'==' / '!=' / '<<' / '>>' / '[]' / '**' / '<=' / '>=' / '-@' / '=~' / 
-		'<' / '>' / '&' / '|' / '*' / '/' / '%' / '+' / '-' / '^' 
-	end
+  rule deprecated_meth_name
+    '_deprecated_' normal_meth_name 
+  end
 
-	rule nominal_meth_name
-    [a-z_] [a-zA-Z0-9_]* [!?=]?
-	end
+  rule normal_meth_name
+    nominal_meth_name / sym_meth_name
+  end
   
+  rule sym_meth_name
+    # Be careful about the order. Remember, it finds a match first
+    '===' / '<=>' / '[]=' / 
+    '!~' / '+@' /
+    '==' / '!=' / '<<' / '>>' / '[]' / '**' / '<=' / '>=' / '-@' / '=~' / 
+    '<' / '>' / '&' / '|' / '*' / '/' / '%' / '+' / '-' / '^' / '~' 
+  end
+
+  rule nominal_meth_name
+    [a-z_] [a-zA-Z0-9_]* [!?=]?
+  end
+
   rule space
     [\s]+
   end

data/lib/rubybreaker/type/type_unparser.rb

@@ -41,8 +41,8 @@ module RubyBreaker
         tokens = tname.split("/")        
         tname = tokens.last if tokens.size > 1
         pp.text(tname)
-			elsif t.instance_of?(SelfType)
-				pp.text("self")
+      elsif t.instance_of?(SelfType)
+        pp.text("self")
       elsif t.instance_of?(DuckType)
         unparse_pp_object_type(pp,t)
       elsif t.instance_of?(FusionType)

data/lib/rubybreaker/typing/subtyping.rb

@@ -331,23 +331,23 @@ module RubyBreaker
       return is_subtype
     end
     
-		# Self type works exactly like nominal type except that, if RHS is a
-		# self type, then only self type is allowed in LHS.
-		#
-		# For example, consider you are inside Fixnum
-		#
-		#   self <: Fixnum
-		#   self <: Numeric
-		#   self <: Object
-		#   self <: self
-		#
-		#   but,
-		#
-		#   Fixnum !<: self
-		#
-		def self.self_subtype_rel?(lhs,rhs)
-			self.nominal_subtype_rel?(lhs,rhs)
-		end
+    # Self type works exactly like nominal type except that, if RHS is a
+    # self type, then only self type is allowed in LHS.
+    #
+    # For example, consider you are inside Fixnum
+    #
+    #   self <: Fixnum
+    #   self <: Numeric
+    #   self <: Object
+    #   self <: self
+    #
+    #   but,
+    #
+    #   Fixnum !<: self
+    #
+    def self.self_subtype_rel?(lhs,rhs)
+      self.nominal_subtype_rel?(lhs,rhs)
+    end
 
     # This method checks the subtype relation when LHS is a nominal type.
     # There are several cases to consider:
@@ -367,8 +367,8 @@ module RubyBreaker
     def self.nominal_subtype_rel?(lhs,rhs)
       return false unless lhs.kind_of?(NominalType) # Self type is a nominal type
       if rhs.instance_of?(SelfType)
-				is_subtype = lhs.instance_of?(SelfType)
-			elsif rhs.instance_of?(NominalType) # don't include self type
+        is_subtype = lhs.instance_of?(SelfType)
+      elsif rhs.instance_of?(NominalType) # don't include self type
         is_subtype = RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
       elsif rhs.instance_of?(FusionType)
         # If RHS is a superclass or included module then true
@@ -444,8 +444,8 @@ module RubyBreaker
         is_subtype = rhs.instance_of?(NilType)
       elsif lhs.instance_of?(AnyType)
         is_subtype = true 
-			elsif lhs.instance_of?(SelfType)
-				is_subtype = self.self_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(SelfType)
+        is_subtype = self.self_subtype_rel?(lhs,rhs)
       elsif lhs.instance_of?(NominalType)
         is_subtype = self.nominal_subtype_rel?(lhs,rhs)
       elsif lhs.instance_of?(FusionType)

data/lib/rubybreaker/util.rb

@@ -17,7 +17,7 @@ module RubyBreaker
       word
     end
     
-		# File activesupport/lib/active_support/inflector/methods.rb
+    # File activesupport/lib/active_support/inflector/methods.rb
     def self.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
       if first_letter_in_uppercase
         lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
@@ -28,4 +28,14 @@ module RubyBreaker
 
   end
 
+  # http://mentalized.net/journal/2010/04/02/suppress_warnings_from_ruby/
+  module Kernel
+    def suppress_warning
+      original_verbosity = $VERBOSE
+      $VERBOSE = nil
+      result = yield
+      $VERBOSE = original_verbosity
+      return result
+    end
+  end
 end

data/lib/rubybreaker.rb

@@ -24,21 +24,10 @@ module RubyBreaker
     :rubylib => true,              # include core ruby library documentation?
   }
 
-  # 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 module to support both states.
-
-  # This array lists modules/classes that will be monitored.
-  BREAKABLE = []
-
   # This array lists modules/classes that are actually instrumented with a
   # monitor.
   INSTALLED = []
   
-  # This array lists "broken" classes--i.e., with type signatures
-  BROKEN = []
-
   # This array lists monitored modules/classes that are outputed.
   DOCUMENTED = []
 
@@ -58,14 +47,15 @@ module RubyBreaker
     # module/class.
     def self.setup()
 
-      BREAKABLE.each do |m|
+      BREAKABLE.each do |mod|
         # Avoid already installed module or now Broken module. Remember,
         # once a module is a declared to be Broken, it wins. Broken modules
         # cannot be Breakable!
-        unless INSTALLED.include?(m) || BROKEN.include?(m)
-          MonitorInstaller.install_module_monitor(m,true)
-          INSTALLED << m
+        unless INSTALLED.include?(mod) || BROKEN.include?(mod)
+          MonitorInstaller.install_module_monitor(mod)
+          INSTALLED << mod
         end
+
       end
 
       # At the end, we generate an output of the type information.
@@ -81,6 +71,71 @@ module RubyBreaker
       eval "load \"#{OPTIONS[:io_file]}\"", TOPLEVEL_BINDING
     end
 
+    # Pretty prints type information for methods
+    def self.pp_methods(pp, meth_type_map)
+      meth_type_map.each { |meth_name, meth_type|
+        case meth_type
+        when MethodType
+          pp.breakable()
+          pp.text("typesig(\"")
+          TypeUnparser.unparse_pp(pp,meth_type)
+          pp.text("\")")
+        when MethodListType
+          meth_type.types.each { |real_meth_type|
+            pp.breakable()
+            pp.text("typesig(\"")
+            TypeUnparser.unparse_pp(pp,real_meth_type)
+            pp.text("\")")
+          }
+        else
+          # Can't happen
+        end
+      }
+    end
+
+    # Pretty prints type information for the module/class
+    def self.pp_module(pp, mod)
+      # Skip it if we already have seen it
+      return if DOCUMENTED.include?(mod) || mod.to_s[0..1] == "#<"
+
+      # Remember that we have documented this module/class
+      DOCUMENTED << mod  
+
+      # Get the method type mapping
+      meth_type_map = Inspector.inspect_all(mod)
+
+      # Check if this module is a class
+      keyword = mod.instance_of?(Class) ? "class" : "module"
+      
+      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)
+          DOCUMENTED << eigen
+          eigen_meth_type_map = Inspector.inspect_all(eigen)
+          if eigen_meth_type_map.size > 0 
+            pp.breakable()
+            pp.text("class << self", 80)
+            pp.nest(2) do
+              self.pp_methods(pp, eigen_meth_type_map)
+            end
+            pp.breakable()
+            pp.text("end", 80)
+          end
+        end
+        self.pp_methods(pp, meth_type_map)
+
+      end
+      pp.breakable() 
+      pp.text("end",80)
+      pp.breakable()
+    end
+
     # This method will generate the output 
     def self.output()
 
@@ -90,44 +145,11 @@ module RubyBreaker
       pp = PrettyPrint.new(str)
 
       # Document each module that was monitored
-      INSTALLED.each do |mod|
-
-        # Skip it if we already have seen it
-        next if DOCUMENTED.include?(mod)
-        DOCUMENTED << mod 
-
-        pp.text("class #{mod.to_s}")
-        pp.nest(2) do 
-          pp.breakable("")
-          pp.text("include RubyBreaker::Broken")
-          meth_type_map = Inspector.inspect_all(mod)
-          meth_type_map.each { |meth_name, meth_type|
-            case meth_type
-            when MethodType
-              pp.breakable()
-              pp.text("typesig(\"")
-              TypeUnparser.unparse_pp(pp,meth_type)
-              pp.text("\")")
-            when MethodListType
-              meth_type.types.each { |real_meth_type|
-                pp.breakable()
-                pp.text("typesig(\"")
-                TypeUnparser.unparse_pp(pp,real_meth_type)
-                pp.text("\")")
-              }
-            else
-              # Can't happen
-            end
-          }
-        end
-        pp.breakable() 
-        pp.text("end")
-        pp.breakable()
-      end
+      INSTALLED.each { |mod| self.pp_module(pp, mod) }
       pp.flush
 
       # First, display the result on the stdout if set
-      puts str if OPTIONS[:stdout]
+      print str if OPTIONS[:stdout]
 
       # If this was a library mode run, exit now. 
       return if OPTIONS[:mode] == :lib
@@ -136,11 +158,10 @@ module RubyBreaker
       open(OPTIONS[:io_file],"a") do |f|
         unless io_exist 
           f.puts "# This file is auto-generated by RubyBreaker"
-          # f.puts "require \"rubybreaker\""
+          f.puts "require \"rubybreaker\""
         end
         f.puts str
       end
-
     end
 
     # This method will run the input file
@@ -170,7 +191,7 @@ module RubyBreaker
 
       if OPTIONS[:rubylib]
         # Load the core library type documentation
-        eval("require \"#{File.dirname(__FILE__)}/rubybreaker/rubylib\"", TOPLEVEL_BINDING)
+        eval("require \"rubybreaker/rubylib\"", TOPLEVEL_BINDING)
       end
 
       # Read the input file first (as it might contain type documentation
@@ -178,7 +199,7 @@ module RubyBreaker
       Main.input()
 
       # Finally, require the program file! Let it run! Wheeee!
-      eval "require '#{prog_file}'", TOPLEVEL_BINDING
+      eval("require '#{prog_file}'", TOPLEVEL_BINDING)
 
     end
 

data/test/integrated/tc_class_methods.rb

@@ -0,0 +1,35 @@
+require "test/unit"
+require_relative "../../lib/rubybreaker"
+
+class IntegratedClassMethodsTest < Test::Unit::TestCase
+  include RubyBreaker
+  include RubyBreaker::TestCase
+
+  class A
+    include RubyBreaker::Breakable
+    def self.foo(x); x.to_s end
+  end
+
+  class B
+    include RubyBreaker::Broken
+    class << self
+      typesig("bar(fixnum[to_s]) -> string")
+      def bar(x); x.to_s end
+    end
+  end
+
+  def test_class_methods
+    A.foo(1)
+    a_foo_meth_type = Runtime::Inspector.inspect_class_meth(A, :foo)
+    str = RubyBreaker::TypeUnparser.unparse(a_foo_meth_type)
+    assert_equal("foo(fixnum[to_s]) -> string", str)
+  end
+
+  def test_broken_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)
+  end
+
+end
+

data/test/integrated/tc_inherit_broken.rb

@@ -0,0 +1,29 @@
+require "test/unit"
+require_relative "../../lib/rubybreaker"
+
+class IntegratedInheritBrokenTest < Test::Unit::TestCase
+  include RubyBreaker
+  include RubyBreaker::TestCase
+
+  class A
+    include RubyBreaker::Broken
+    typesig("foo(fixnum[to_s]) -> string")
+    def foo(x); x.to_s end
+  end
+
+  class B < A
+    include RubyBreaker::Breakable
+    def bar(x); foo(x) end
+  end
+
+  def test_both
+    b = B.new
+    b.bar(1)
+    b_meth_type = Runtime::Inspector.inspect_meth(B, :bar)
+    str = RubyBreaker::TypeUnparser.unparse(b_meth_type)
+    assert_equal("bar(fixnum[to_s]) -> string", str)
+  end
+
+end
+
+

data/test/integrated/tc_method_missing.rb

@@ -23,7 +23,7 @@ class IntegratedMethodMissingTest < Test::Unit::TestCase
     meth_type = Runtime::Inspector.inspect_meth(A, :method_missing)
     str = RubyBreaker::TypeUnparser.unparse(meth_type)
     # puts str
-    assert_equal("method_missing(symbol[to_s], fixnum[to_s], fixnum[to_s]) -> string", str, "A#foo failed.")
+    assert_equal("method_missing(symbol[to_s], fixnum[to_s]*) -> string", str, "A#foo failed.")
   end
   
 end

data/test/runtime/tc_obj_wrapper.rb

@@ -1,6 +1,5 @@
-dir = File.dirname(__FILE__)
 require "test/unit"
-require "#{dir}/../../lib/rubybreaker/runtime"
+require_relative "../../lib/rubybreaker/runtime"
 
 class ObjectWrapperTest < Test::Unit::TestCase
   include RubyBreaker
@@ -54,7 +53,7 @@ class ObjectWrapperTest < Test::Unit::TestCase
     assert_equal(x.object_id, wrapped_x.object_id)
   end
 
-  def test_equal()
+  def test_equalities_fixnum()
     x = 42
     wrapped_x = Runtime::ObjectWrapper.new(x)
     assert(wrapped_x == wrapped_x)
@@ -62,7 +61,7 @@ class ObjectWrapperTest < Test::Unit::TestCase
     assert(wrapped_x.eql?(wrapped_x))
     assert(42 == wrapped_x)
     assert(wrapped_x == 42)
-    assert(42.equal?(wrapped_x))
+    assert(42.equal?(wrapped_x)) # try 42.equal?(42) in irb, it will work!
     assert(wrapped_x.equal?(42))
     assert(42.eql?(wrapped_x))
     assert(wrapped_x.eql?(42))
@@ -70,4 +69,105 @@ class ObjectWrapperTest < Test::Unit::TestCase
     assert_equal(42, wrapped_x)
   end
 
+  def test_equalities_string()
+    x = "42"
+    y = "42"
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    assert(wrapped_x == wrapped_x)
+    assert(wrapped_x.equal?(wrapped_x))
+    assert(wrapped_x.eql?(wrapped_x))
+    assert(y == wrapped_x)
+    assert(wrapped_x == y)
+    assert(!y.equal?(wrapped_x)) # try "42".equal?("42") in irb, it will fail
+    assert(wrapped_x.equal?(y))
+    assert(y.eql?(wrapped_x))
+    assert(wrapped_x.eql?(y))
+    assert_equal(y, wrapped_x)
+    assert_equal(y, wrapped_x)
+  end
+
+  def test_equalities_symbol()
+    x = :"42"
+    y = :"42"
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    assert(wrapped_x == wrapped_x)
+    assert(wrapped_x.equal?(wrapped_x))
+    assert(wrapped_x.eql?(wrapped_x))
+    assert(y == wrapped_x)
+    assert(wrapped_x == y)
+    assert(y.equal?(wrapped_x)) # try :"42".equal?(:"42") in irb, it will work
+    assert(wrapped_x.equal?(y))
+    assert(y.eql?(wrapped_x))
+    assert(wrapped_x.eql?(y))
+    assert_equal(y, wrapped_x)
+    assert_equal(y, wrapped_x)
+  end
+
+  def test_equalities_array()
+    x = [1,2]
+    y = [1,2]
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    assert(wrapped_x == wrapped_x)
+    assert(wrapped_x.equal?(wrapped_x))
+    assert(wrapped_x.eql?(wrapped_x))
+    assert(y == wrapped_x)
+    assert(wrapped_x == y)
+    assert(!y.equal?(wrapped_x))
+    assert(wrapped_x.equal?(y))
+    assert(y.eql?(wrapped_x))
+    assert(wrapped_x.eql?(y))
+    assert_equal(y, wrapped_x)
+    assert_equal(y, wrapped_x)
+  end
+
+  def test_inequalities_array()
+    x = [1,2]
+    y = [1,3]
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    assert(wrapped_x == wrapped_x)
+    assert(wrapped_x.equal?(wrapped_x))
+    assert(wrapped_x.eql?(wrapped_x))
+    assert(y != wrapped_x)
+    assert(wrapped_x != y)
+    assert(!y.equal?(wrapped_x))
+    assert(!wrapped_x.equal?(y))
+    assert(!y.eql?(wrapped_x))
+    assert(!wrapped_x.eql?(y))
+    assert_not_equal(y, wrapped_x)
+    assert_not_equal(y, wrapped_x)
+  end
+
+  def test_equalities_hash()
+    x = { :a => 1, :b => 2}
+    y = { :a => 1, :b => 2}
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    assert(wrapped_x == wrapped_x)
+    assert(wrapped_x.equal?(wrapped_x))
+    assert(wrapped_x.eql?(wrapped_x))
+    assert(y == wrapped_x)
+    assert(wrapped_x == y)
+    assert(!y.equal?(wrapped_x)) 
+    assert(wrapped_x.equal?(y))
+    assert(y.eql?(wrapped_x))
+    assert(wrapped_x.eql?(y))
+    assert_equal(y, wrapped_x)
+    assert_equal(y, wrapped_x)
+  end
+
+  def test_inequalities_hash()
+    x = { :a => 1, :b => 2}
+    y = { :a => 1, :b => 3}
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    assert(wrapped_x == wrapped_x)
+    assert(wrapped_x.equal?(wrapped_x))
+    assert(wrapped_x.eql?(wrapped_x))
+    assert(y != wrapped_x)
+    assert(wrapped_x != y)
+    assert(!y.equal?(wrapped_x)) 
+    assert(!wrapped_x.equal?(y))
+    assert(!y.eql?(wrapped_x))
+    assert(!wrapped_x.eql?(y))
+    assert_not_equal(y, wrapped_x)
+    assert_not_equal(y, wrapped_x)
+  end
 end

data/test/ts_integrated.rb

@@ -2,3 +2,5 @@
 require "test/unit"
 require_relative "integrated/tc_method_missing"
 require_relative "integrated/tc_simple1"
+require_relative "integrated/tc_inherit_broken"
+require_relative "integrated/tc_class_methods"