rubybreaker 0.0.5 → 0.0.6

data/TUTORIAL.md

@@ -0,0 +1,291 @@
+# Tutorial
+
+This tutorial will describe the basic usage of the tool, the RubyBreaker
+Type Annotation Language, and the RubyBreaker Type System.
+
+## Usage
+
+RubyBreaker takes advantage of test cases that already come with the source
+program.  It is recommended that RubyBreaker is run as a Rake task, which
+does require a minimum change in the Rakefile (but no code change in the
+source program) but is better for a long-term maintenance. Regardless of the
+mode you choose to run, no source code change is required. 
+
+Let us briefly see how RubyBreaker can be run directly as a command-line
+program to understand the overall concept of the tool. We will explain how
+to use RubyBreaker in a Rakefile later.
+
+    $ rubybreaker -v -s -l lib.rb -b A,B prog.rb
+
+The above command runs RubyBreaker in verbose mode (`-v`) and will display
+the output on the screen (`-s`). Before RubyBreaker runs `prog.rb`, it will
+import (`-l`) `lib.rb` and instrument (`-b`) classes `A` and `B`.
+Here is `lib.rb`:
+
+    class A
+      def foo(x)
+        x.to_s
+      end
+    end
+    class B
+      def bar(y,z)
+        y.foo(z)
+      end
+    end
+
+And, `prog.rb` simply imports the library file and executes it:
+
+    require "lib"
+    A.new.foo(1)
+
+This example will show how `A#foo` method is given a type by RubyBreaker.
+After running the command shown above, the following output will be
+generated and displayed on the screen:
+
+    class A
+      typesig("foo(fixnum[to_s]) -> string")
+    end
+
+Here, the `typesig` method call registers `foo` as a method type that takes
+an object that has `Fixnum#to_s` method and returns a `String`. This
+method is made available simply by importing `rubybreaker`.  Now, assume
+that an additional code, `B.new.bar(A.new,1)`, is added at the end of
+`prog.rb`. The subsequent run will generate the following result:
+
+    class A
+      typesig("foo(fixnum[to_s]) -> string")
+    end
+    class B
+      typesig("bar(a[foo], fixnum[to_s]) -> string")
+    end
+
+Keep in mind that RubyBreaker is designed to gather type information based
+on the _actual_ execution of the source program. This means the program
+should be equipped with test cases that have a reasonable program path
+coverage.  Additionally, RubyBreaker assumes that test runs are correct and
+the program behaves correctly (for those test runs) as intended by the
+programmer. This assumption is not a strong requirement, but is necessary to
+obtain precise and accurate type information. 
+
+### Using Ruby Unit Testing Framework
+
+Instead of manually inserting the entry point indicator in the source
+program, you can take advantage of Ruby's built-in testing framework. This
+is preferred to modifying the source program directly, especially for the
+long term program maintainability. But no worries! This method is as simple
+as the previous one.
+
+    require "test/unit"
+    require "rubybreaker" # This should come after test/unit.
+    class TestClassA < Test::Unit::TestCase
+      def setup()
+         RubyBreaker.break(Class1, Class2, ...)
+         ...
+      end
+      # ...tests!...
+    end
+
+That's it! The only requirements are to indicate to RubyBreaker which modules
+and classes to "break" and to place `require rubybreaker` _after_
+`require test/unit`.
+
+### Using RSpec
+
+The requirement is same for RSpec but use `before` instead of `setup` to
+specify which modules and classes to "break".
+
+    require "rspec"
+    require "rubybreaker"
+
+    describe "TestClassA Test"
+      before { RubyBreaker.break(Class1, Class2, ...) }
+      ...
+      # ...tests!...
+    end
+
+### Using Rakefile
+
+By running RubyBreaker along with the Rakefile, you can avoid modifying the
+source program at all. (You no longer need to import `rubybreaker` in the
+test cases neither.) Therefore, this is the recommended way to use
+RubyBreaker.  The following code snippet describes how it can be done:
+
+    require "rubybreaker/task"
+    ...
+    desc "Run RubyBreaker"
+    Rake::RubyBreakerTestTask.new(:"rubybreaker") do |t|
+      t.libs << "lib" 
+      t.test_files = ["test/foo/tc_foo1.rb"]
+      # ...Other test task options..
+      t.rubybreaker_opts << "-v"               # run in verbose mode
+      t.break = ["Class1", "Class2", ...]  # specify what to monitor
+    end
+
+Note that `RubyBrakerTestTask` can simply replace your `TestTask` block in
+Rakefile. In fact, the former is a subclass of the latter and includes all
+features supported by the latter. The only additional options are
+`rubybreaker_opts` which is RubyBreaker's command-line options and
+`break` which specifies which modules and classes to monitor.  Since
+`Class1` and `Class2` are not _recognized_ by this Rakefile, you must use
+string literals to specify modules and classes (and with full namespace). 
+
+If this is the route you are taking, there needs no editing of the source
+program whatsoever. This task will take care of instrumenting the specified
+modules and classes at proper moments.
+
+## Type Annotation
+
+The annotation language used in RubyBreaker resembles the method
+documentation used by Ruby Core Library Doc. Each type signature
+defines a method type using the name, argument types, block type, and return
+type. But, let us consider a simple case where there is one argument type
+and a return type. 
+
+    class A
+      ...
+      typesig("foo(fixnum) -> string")
+    end
+
+In RubyBreaker, a type signature is recognized by the meta-class level
+method `typesig` which takes a string as an argument.  This string is the
+actual type signature written in the Ruby Type Annotation Language. This
+language is designed to reflect the common documentation practice used by
+Ruby Core Library Doc. It starts with the name of the method. In the
+above example, `foo` is currently being given a type. The rest of the
+signature takes a typical method type symbol, `(x) -> y` where `x` is the
+argument type and `y` is the return type. In the example shown above, the
+method takes a `Fixnum` object and returns a `String` object. Note that
+these types are in lowercase, indicating they are objects and not modules or
+classes themselves.
+
+There are several types that represent an object: nominal, duck, fusion,
+nil, 'any', 'or', optional, variable-length, and block. Each type signature
+itself represents a method type or a method list type (explained below). 
+
+### Nominal Type
+
+This is the simplest and most intuitive way to represent an object. For
+instance, `fixnum` is an object of type `Fixnum`. Use lower-case letters and
+underscores instead of _camelized_ name. `MyClass`, for example would be
+`my_class` in RubyBreaker type signatures. There is no particular
+reason for this convention other than it is the common practice used in
+RubyDoc. Use `/` to indicate the namespace delimiter `::`. For example,
+`NamspaceA::ClassB` would be represented by `namespace_a/class_b` in
+a RubyBreaker type signature.
+
+### Self Type
+
+This type is similar to the nominal type but is referring to the current
+object--that is, the receiver of the method being typed. RubyBreaker will
+auto-document the return type as a self type if the return value is the same
+as the receiver of that call. It is also recommended to use this type over
+a nominal type (if the return value is `self`) since it depicts more
+precise return type.
+
+### Duck Type
+
+This type is inspired by the Ruby Language's duck typing, _"if it
+walks like a duck and quacks like a duck, it must be a duck."_ Using this
+type, an object can be represented simply by a list of method names. For
+example `[walks, quacks]` is an object that has `walks` and `quacks`
+methods. Note that these method names do *not* reveal any type
+information for themselves.
+
+### Fusion Type
+
+Duck type is very flexible but can be too lenient when trying to restrict
+the type of an object. RubyBreaker provides a type called *the fusion type*
+which lists method names but with respect to a nominal type. For
+example, `fixnum[to_f, to_s]` represents an object that has methods `to_f`
+and `to_s` whose types are same as those of `Fixnum`. This is more
+restrictive (precise) than `[to_f, to_s]` because the two methods must have
+the same types as `to_f` and `to_s` methods, respectively, in `Fixnum`.
+
+### Nil Type
+
+A nil type represents a value of nil and is denoted by `nil`.
+
+### Any Type
+
+RubyBreaker also provides a way to represent an object that is compatible with
+any type. This type is denoted by `?`. Use caution with this type because
+it should be only used for an object that requires an arbitrary yet most
+specific type--that is, `?` is a subtype of any other type, but any
+other type is not a subtype of `?`. This becomes a bit complicated for
+method or block argument types because of their contra-variance
+characteristic. Please refer to the section *Subtyping*.
+
+### Or Type
+
+Any above types can be "or"ed together, using `||`, to represent an object
+that can be either one or the other. It _does_ not represent an object that
+has to be both (which is not supported by RubyBreaker).
+
+### Optional Argument Type and Variable-Length Argument Type
+
+Another useful features of Ruby are the optional argument type and the
+variable-length argument type. The former represents an argument that has a
+default value (and therefore does not have to be provided). The latter
+represents zero or more arguments of the same type. These are denoted by
+suffices, `?` and `*`, respectively.
+
+### Block Type
+
+One of the Ruby's prominent features is the block argument. It allows
+the caller to pass in a piece of code to be executed inside the callee. This
+code block can be executed by the Ruby construct, `yield`, or by directly
+calling the `call` method of the block object. In RubyBreaker, this type can
+be respresented by curly brackets. For instance, `{|fixnum,string| ->
+string}` represents a block that takes two arguments--one `Fixnum` and one
+`String`--and returns a `String`. 
+
+RubyBreaker does supports nested blocks as Ruby 1.9 finally allows them.
+However, *keep in mind* that RubyBreaker *cannot* automatically document the
+block types due to `yield` being a language construct rather than a method,
+which means it cannot be captured by meta-programming!
+
+### Method Type and Method List Types
+
+Method type is similar to the block type, but it represents an actual method
+and not a block object. It is the "root" type that the type annotation
+language supports, along with method list types. Method _list_ type is a
+collection of method types to represent more than one type information for
+the given method. Why would this type be needed? Consider the following Ruby
+code:
+
+    def foo(x)
+      case x
+      when Fixnum
+        1
+      when String
+        "1"
+      end
+    end
+
+There is no way to document the type of `foo` without using a method list
+type. Let's try to give a method type to `foo` without a method list. The
+closest we can come up with would be `foo(fixnum or string) -> fixnum and
+string`. But RubyBreaker does not have the "and" type in the type annotation
+language because it gives me an headache! (By the way, it needs to be an
+"and" type because the caller must handle both `Fixnum` and `String` return
+values.) 
+
+It is a dilemma because Ruby programmers actually enjoy using this kind of
+dynamic type checks in their code. To alleviate this headache, RubyBreaker
+supports the method list type to represent different scenarios depending on
+the argument types. Thus, the `foo` method shown above can be given the
+following method list type:
+
+    typesig("foo(fixnum) -> fixnum")
+    typesig("foo(string) -> string")
+
+These two type signatures simply tell RubyBreaker that `foo` has two method
+types--one for a `Fixnum` argument and another for a `String` argument.
+Depending on the argument type, the return type is determined. In this
+example, a `Fixnum` is returned when the argument is also a `Fixnum` and a
+`String` is returned when the argument is also a `String`. When
+automatically documenting such a type, RubyBreaker looks for the (subtyping)
+compatibility between the return types and "promote" the method type to a
+method list type by spliting the type signature into two (or more in
+subsequent "promotions").
+

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/bin/rubybreaker

@@ -23,32 +23,50 @@ module RubyBreaker
     # Quit if there is program specified.
     self.show_banner_and_exit() if ARGV.length != 1
 
+    # It is required to specify at least one library and one module/class to
+    # break. Otherwise, it does not make sense to run RubyBreaker. So it
+    # will quit.
+    if OPTIONS[:libs].empty?
+      STDERR.puts "No library is specified."
+      exit(1)
+    elsif OPTIONS[:break].empty?
+      STDERR.puts "No module/class is specified to break."
+      exit(1)
+    end
+
     # Get the specified program.
-    prog = ARGV[0]
-    prog_file = File.expand_path(prog)
+    prog_name = ARGV[0]
+    prog = File.expand_path(prog_name)
 
-    # It is ok to omit .rb extension. So try to see if prog_file.rb exists
-    if !File.exist?(prog_file) && !File.extname(prog_file) == ".rb" 
-      prog_file = "#{prog_file}.rb"
+    # It is ok to omit .rb extension. So try to see if prog.rb exists
+    if !File.exist?(prog) && !File.extname(prog) == ".rb" 
+      prog = "#{prog}.rb"
     end 
 
     # Quit the specified program does not exist.
-    if !File.exist?(prog_file)
+    if !File.exist?(prog)
       fatal("#{ARGV[0]} is an invalid file.")
       exit(1)
     end
 
     # Remember the program path for later use
-    OPTIONS[:prog_file] = prog_file
+    OPTIONS[:prog] = prog
 
-    # Run the program file!
-    self.verbose("Running #{prog}")
-    eval "require '#{prog_file}'", TOPLEVEL_BINDING
-    self.verbose("Done running #{prog}")
+    # Import the libraries specified.
+    OPTIONS[:libs].each do |lib|
+      # Run the program file!
+      self.verbose("Importing #{lib}")
+      eval "require '#{lib}'", TOPLEVEL_BINDING
+      self.verbose("Done importing #{lib}")
+    end
 
-    # Keep in mind that the source program must specify the entry
-    # point--using RubyBreaker.run()--in order to observe the type
-    # information.
+    # Now, RubyBreaker shell mode will run this
+    RubyBreaker.run()
+
+    # Run the program file!
+    self.verbose("Running #{prog_name}")
+    eval "require '#{prog}'", TOPLEVEL_BINDING
+    self.verbose("Done running #{prog_name}")
   end
 
 end

data/lib/rubybreaker/runtime/monitor.rb

@@ -206,7 +206,7 @@ module RubyBreaker
       end
 
       # Installs an module (class) monitor to the object. 
-      def self.install_module_monitor(mod)
+      def self.install_monitor(mod)
 
         RubyBreaker.log("Installing module monitor for #{mod}")
 

data/lib/rubybreaker/runtime.rb

@@ -24,37 +24,26 @@ module RubyBreaker
     # This hash maps a (breakable) module to a type monitor
     MONITOR_MAP = {}  # module => monitor
 
-    # This set lists modules/classes that are actually instrumented with a
-    # monitor.
-    INSTALLED = Set.new
+    private
 
-    # 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
-
-    # This method modifies specified modules/classes at the very moment
-    # (instead of registering them for later).
-    def self.breakable(*mods)
+    # Instruments the monitor to the specified modules/classes. 
+    #
+    # TODO: monitor_type is currently not in use. Plan on using it in future
+    #       to do type checker instrumentation
+    def self.install(monitor_type=:break, *mods)
       mods.each do |mod|
         case mod
         when Array
-          self.breakable(*mod)
+          self.install(monitor_type, *mod)
         when Module, Class
-          MonitorInstaller.install_module_monitor(mod)
+          MonitorInstaller.install_monitor(mod)
           eigen_class = self.eigen_class(mod)
-          MonitorInstaller.install_module_monitor(eigen_class)
-          INSTALLED << mod << eigen_class
+          MonitorInstaller.install_monitor(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
+            self.install(monitor_type, mod) if mod
           rescue NameError => e
             RubyBreaker.error("#{mod} cannot be found.")
           end
@@ -63,6 +52,31 @@ module RubyBreaker
         end
       end
     end
+
+    public
+
+    # This method instruments the specified modules/classes at the time of
+    # the call.
+    def self.break(*mods)
+      self.install(:break, *mods)
+    end
+
+    # 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_monitor(mod)
+      end
+    end
+
+    # This method modifies specified modules/classes at the very moment
+    # (instead of registering them for later).
+    # *DEPRECATED*: Use +break()+ method instead
+    def self.breakable(*mods)
+      self.install(:break, *mods)
+    end
+
   end
 
   # *DEPRECATED*: Use +RubyBreaker.run()+ to indicate the point of entry.
@@ -70,10 +84,16 @@ module RubyBreaker
   end
 
   # This method just redirects to Runtime's method.
+  # *DEPRECATED*: Use +RubyBreaker.break()+ to indicate the point of entry.
   def self.breakable(*mods)
     Runtime.breakable(*mods)
   end
 
+  # This method just redirects to Runtime's method.
+  def self.break(*mods)
+    Runtime.break(*mods)
+  end
+
   # *DEPRECATED*: Use +Runtime.breakable()+ or +RubyBreaker.run()+ method
   #               instead.
   module Breakable  

data/lib/rubybreaker/task.rb

@@ -16,17 +16,23 @@ module Rake
   # Rake::RubyBreakerTestTask.new(:"testtask_test") do |t|
   #   t.libs << "lib"
   #   t.test_files = ["test/testtask/tc_testtask.rb"]
-  #   t.breakable = ["SampleClassA"]
+  #   t.break = ["SampleClassA"]
   # end
   #
   class RubyBreakerTestTask < Rake::TestTask
 
-    # List of Breakable modules/classes
-    attr_accessor :breakable
+    # List of modules/classes to break
+    attr_accessor :break
 
     # RubyBreaker options
     attr_accessor :rubybreaker_opts
 
+    # DEPRECATED accessor override
+    def breakable(); @break end
+
+    # DEPRECATED accessor override
+    def breakable=(*args); self.break(*args) end
+
     # 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.
@@ -34,7 +40,7 @@ module Rake
 
       # Initialize extra instance variables
       @rubybreaker_opts = []
-      @breakable = nil
+      @break = nil
 
       # Call the original constructor first
       super(taskname, *args, &blk)
@@ -51,14 +57,14 @@ module Rake
 
       # 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,
+        :name => taskname,
+        :rubybreaker_opts => opts,
+        :break => [], # 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
+      @break.each { |b| config[:break] << b } if @break
 
       # 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/test/rspec.rb

@@ -2,13 +2,13 @@
 # This file overrides the describe method of RSpec to call the RubyBreaker
 # setup first.
 
-RUBYBREAKER_RSPEC_PREFIX = "__rubybreaker"
+RUBYBREAKER_RSPEC_PREFIX = "__rubybreaker" #:nodoc:
 
 if defined?(RSpec)
-  alias :"#{RUBYBREAKER_RSPEC_PREFIX}_describe" :describe
+  alias :"#{RUBYBREAKER_RSPEC_PREFIX}_describe" :describe #:nodoc:
 end
 
-def describe(*args,&blk)
+def describe(*args,&blk) #:nodoc:
   RubyBreaker.run if defined?(RubyBreaker) 
   send(:"#{RUBYBREAKER_RSPEC_PREFIX}_describe", *args, &blk)
 end

data/lib/rubybreaker/test/testcase.rb

@@ -6,14 +6,14 @@
 if defined?(Test) && defined?(Test::Unit)
 
   # This class is patched to run RubyBreaker along with the test cases.
-  class Test::Unit::TestCase
+  class Test::Unit::TestCase #:nodoc:
 
     # Save the original constructor method.
-    alias :__rubybreaker_initialize :initialize
+    alias :__rubybreaker_initialize :initialize #:nodoc:
 
     # This method overrides the original constructor to run RubyBreaker before
     # calling the original constructor.
-    def initialize(*args, &blk)
+    def initialize(*args, &blk) #:nodoc:
       RubyBreaker.run()
       return send(:__rubybreaker_initialize, *args, &blk)
     end

data/lib/rubybreaker.rb

@@ -1,7 +1,9 @@
 #--
-# This library dynamically profiles and resolves the type information
-# observed at runtime and generates type annotation at the end.  It can be
-# run as either a stand-alone script or as a Ruby library. 
+# This library dynamically instruments the source program, runs the program
+# on Ruby, and produces type documentation based on the observation made
+# during runtime. Although it is possible to use this as a typical Ruby
+# library, our recommendation is to use it in Rakefile or use it as a
+# command-line program. See TUTORIAL for more detail.
 
 require "set"
 require "optparse"
@@ -10,21 +12,23 @@ require_relative "rubybreaker/runtime"
 require_relative "rubybreaker/test"
 
 # RubyBreaker is a dynamic instrumentation and monitoring tool that
-# generates type documentation for Ruby programs. 
+# generates type documentation automatically for Ruby programs. 
 module RubyBreaker
   include TypeDefs
   include Runtime
 
   # Options for RubyBreaker
   OPTIONS = {
-    :debug     => false,       # in debug mode?
-    :style     => :underscore, # type signature style-underscore or camelize
-    :io_file   => nil,         # generate input/output other than default?
-    :append    => false,       # append to the input file (if there is)?
-    :stdout    => false,       # also display on the screen?
-    :verbose   => false,       # in RubyBreaker.verbose mode?
+    :debug        => false,       # in debug mode?
+    :style        => :underscore, # type signature style-underscore or camelize
+    :io_file      => nil,         # generate input/output other than default?
+    :append       => false,       # append to the input file (if there is)?
+    :stdout       => false,       # also display on the screen?
+    :verbose      => false,       # in RubyBreaker.verbose mode?
     :save_output  => true,     # save output to a file?
-    :prog_file    => nil,      # INTERNAL USE ONLY
+    :break        => [],       # modules to break
+    :libs         => [],       # list of library files to import
+    :prog         => nil,      # program or test file
   }
 
   # This option parser may be used for the command-line mode or for the
@@ -34,6 +38,16 @@ module RubyBreaker
 
     opts.banner = "Usage: #{File.basename(__FILE__)} [options] prog[.rb]" 
 
+    opts.on("-b MODULES", "--break MODULES", "Specify modules/classes to 'break'") do |s|
+      tokens = s.split(/[;,]/)
+      tokens.each {|t| OPTIONS[:break] << t}
+    end
+    
+    opts.on("-l LIBRARIES", "--libs LIBRARIES", "Specify libraries to load") do |s|
+      tokens = s.split(":")
+      tokens.each {|t| OPTIONS[:libs] << t}
+    end
+
     opts.on("--debug", "Run in debug mode") do 
       OPTIONS[:debug] = true
     end
@@ -104,7 +118,7 @@ module RubyBreaker
     code = ""
 
     # Document each module that was monitored.
-    INSTALLED.each { |mod| 
+    MONITOR_MAP.each_key { |mod| 
       str = Runtime::TypeSigUnparser.unparse(mod) 
       code << str
       print str if OPTIONS[:stdout] # display on the screen if requested
@@ -157,12 +171,13 @@ module RubyBreaker
       RubyBreaker.verbose("Running RubyBreaker within a testcase")
       task = self.task
       OPTION_PARSER.parse(*task[:rubybreaker_opts])
-      Runtime.breakable(*task[:breakable])
+      Runtime.break(*task[:break])
       task_name = task[:name]
       RubyBreaker.verbose("Done reading task information")
       io_file = self.io_file(task_name)
-    elsif OPTIONS[:prog_file] # running in shell mode 
-      Runtime.breakable(*mods)
+    elsif OPTIONS[:prog] # running in shell mode 
+      Runtime.break(*mods) # should not happen but for backward-compatibility
+      Runtime.break(*OPTIONS[:break])
       io_file = self.io_file(OPTIONS[:prog_file])
     else
       # Otherwise, assume there are no explicit IO files.
@@ -179,7 +194,7 @@ module RubyBreaker
 end
 
 # This method is available by default.
-module Kernel
+module Kernel #:nodoc:
 
   def typesig(str)
     _TypeDefs = RubyBreaker::TypeDefs

data/test/integrated/{tc_both_broken_breakable.rb → tc_both_documented_and_undocumented.rb}

@@ -1,21 +1,20 @@
 require "test/unit"
 require_relative "../../lib/rubybreaker"
 
-class IntegratedBothBrokenBreakableTest < Test::Unit::TestCase
+class IntegratedBothDocumentedAndUndocumented < Test::Unit::TestCase
   include RubyBreaker
 
   class A
-    # include RubyBreaker::Breakable
     typesig("foo(fixnum[to_s]) -> string") 
     def foo(x); x.to_s end
     def bar(x); x.to_sym end
   end
 
   def setup
-    RubyBreaker.breakable(A)
+    RubyBreaker.break(A)
   end
 
-  def test_both_broken_and_breakable
+  def test_both_documented_and_undocumented
     A.new.bar("abc")
     a_foo_meth_type = Runtime::Inspector.inspect_meth(A, :foo)
     a_bar_meth_type = Runtime::Inspector.inspect_meth(A, :bar)