rubybreaker 0.0.1

data/lib/rubybreaker/context.rb

@@ -0,0 +1,122 @@
+#--
+# This file defines code location as well as runtime location and context
+# which is made up of one or more locations.
+
+require "prettyprint"
+
+module RubyBreaker
+
+  # This class represents a position of the type acquired from either the
+  # type signature or code during runtime. It can also be used for internal
+  # error checking or debuging purpose.
+  class Position
+    
+    attr_accessor :file
+    attr_accessor :line
+    attr_accessor :col
+    attr_accessor :method
+    
+    @@file = ""
+    @@line = -1
+    @@col = -1
+    
+    def initialize(file="",line=-1,col=-1,meth="")
+      @file = file
+      @line = line
+      @col = col
+      @method = meth
+    end
+
+    def to_s()
+      return "#{@file}:(#{@line},#{@col}):in #{@method}"
+    end
+    
+    # This class method is to set the current parsing position.
+    def self.set(file,line,col)
+      @@file = file
+      @@line = line
+      @@col = col
+    end
+    
+    # This class method returns a new position object for the current
+    # parsing position.
+    def self.get()
+      return Position.new(@@file,@@line,@@col)
+    end
+
+    # This class method is a utility function to convert a string in the
+    # caller() array.
+    def self.convert_caller_to_pos(caller_ary, idx=0)
+      tokens = caller_ary[idx].split(":")
+      return self.new(tokens[0],tokens[1],-1,tokens[2]) # no col 
+    end
+  end
+
+  # This class represents a position with respect to an object and the name
+  # of a method being invoked.
+  class ObjectPosition
+    attr_accessor :obj
+    attr_accessor :meth_name
+
+    def initialize(obj, meth_name)
+      @obj = obj
+      @meth_name = meth_name
+    end 
+
+    def to_s()
+      m_delim = @obj.kind_of?(Module) ? "." : "#"
+      return "> #{@obj.class}#{m_delim}#{@meth_name}"
+    end
+  end
+
+  # This class represents a context which consists of one or more positions.
+  # A position can refer to a physical file/line position or a virtual
+  # position with respect to an object. A context is commonly used to
+  # represent a chain of positions for types.
+  class Context
+
+    attr_accessor :pos   # location is either Position or ObjectPosition
+    attr_accessor :child
+
+    def initialize(pos)
+      @pos = pos
+      @child = nil
+    end
+
+    def push(pos)
+      if @child 
+        @child.push(pos)
+      else
+        @child = Context.new(pos)
+      end
+    end
+
+    def pop
+      if @child && @child.child
+        @child.pop
+      elsif @child
+        @child = nil
+      else 
+        # root; don't do anything
+      end
+    end
+
+    def format_with_msg(pp,msg="")
+      pp.text(@pos.to_s)
+      pp.breakable()
+      if @child
+        pp.group(2) { 
+          pp.breakable()
+          @child.format_with_msg(pp,msg)
+        }
+      elsif msg != ""
+        pp.group(2) do
+          pp.breakable()
+          pp.text("> #{msg}",79)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/rubybreaker/debug.rb

@@ -0,0 +1,48 @@
+#--
+# This file is for debugging RubyBreaker.
+
+require "prettyprint"
+require_relative "context"
+
+module RubyBreaker
+
+  # This module is for internal purpose only - to help ourselves find bugs
+  # and fix them with more informative error messages.
+  module Debug
+
+    OUTPUT = ""
+
+    def self.msg(text,context=nil)
+      return unless RubyBreaker::OPTIONS[:debug]
+      pp = PrettyPrint.new(OUTPUT)
+      msg = "[DEBUG] #{text}"
+      if context
+        context.format_with_msg(pp,msg)
+      else
+        pp.text(msg,79)
+        pp.breakable()
+      end
+      pp.flush
+      puts OUTPUT
+      OUTPUT.replace("")
+    end
+
+    def self.short_msg(text)
+      return unless RubyBreaker::OPTIONS[:debug]
+      msg = "[DEBUG] #{text}"
+      print msg
+    end
+
+    def self.token(msg)
+      return unless RubyBreaker::OPTIONS[:debug]
+      print msg
+    end
+
+    def self.feed_line()
+      return unless RubyBreaker::OPTIONS[:debug]
+      puts ""
+    end
+
+  end
+
+end

data/lib/rubybreaker/error.rb

@@ -0,0 +1,59 @@
+#--
+# This file defines various errors that are used by RubyBreaker both
+# internally and externally.
+
+module RubyBreaker
+
+  # This module contains errors used by RubyBreaker.
+  module Errors
+
+    ########### INTERNAL ERRORS
+
+    # This class is a base class for any internal errors. It should be used to
+    # inform the faults within the program and not related to user programs.
+    class InternalError < ::Exception
+      def initialize(msg)
+        @level = :FATAL if @level == nil 
+        msg = "[#{@level}] #{msg} at #{@pos}" 
+        super(msg)
+      end
+    end
+
+    # This error is thrown when a type is constructed with invalid elements.
+    class InvalidTypeConstruction < InternalError
+    end 
+
+    # This error is thrown when a subtype check is not even appropriate for
+    # two given types. It should NOT BE USED for any check failures. 
+    class InvalidSubtypeCheck < InternalError
+      def initialize(msg,pos=nil)
+        @level = :FATAL
+        @pos = pos ? pos : Position.convert_caller_to_pos(caller(1))
+        super("InvalidSubtypingCheck: #{msg}")
+      end
+    end
+
+    ########### USER ERRORS
+
+    # This class is a base class for any user errors. Unlike internal error,
+    # it should use a Context to inform the source of the error rather than a
+    # Position since user errors tend to generate over multiple points in the
+    # program.
+    class UserError < ::Exception
+      
+      def initialize(msg, ctx)
+        super(msg)
+        @ctx = ctx
+      end
+
+    end
+
+    class TypeError < ::UserError
+    end
+
+    class SubtypeFailure < TypeError
+    end
+
+  end
+
+end