rubybreaker 0.0.1

data/lib/rubybreaker/type/type_comparer.rb

@@ -0,0 +1,143 @@
+#--
+# This file defines (almost) syntactic equivalences between types.
+
+require_relative "../type"
+
+module RubyBreaker
+  
+  # This module compares two RubyBreaker-defined types for the syntactic
+  # equivalence.
+  module TypeComparer
+
+    include TypeDefs
+    
+    private
+    
+    # This method checks if two types are syntactically equivalent. The
+    # order of method names do not matter.
+    def self.duck_compare(lhs,rhs)
+      is_equal = false
+      if lhs.kind_of?(DuckType) && rhs.kind_of?(DuckType) &&
+         lhs.meth_names.size == rhs.meth_names.size
+        is_equal = true
+        lhs.meth_names.each {|mname| 
+          if !rhs.meth_names.include?(mname)
+            is_equal = false
+            break
+          end
+        }
+      end 
+      return is_equal
+    end
+    
+    # This method compares two proc types.
+    def self.proc_compare(lhs, rhs)
+      is_equal = false
+      if lhs.arg_types.size == rhs.arg_types.size
+        is_equal = true
+        # check arguments first
+        lhs.arg_types.each_with_index do |atype,i|
+          if !self.compare(atype,rhs.arg_types[i])
+            is_equal = false
+            break
+          end
+        end
+        # check block types
+        if lhs.blk_type && rhs.blk_type
+          is_equal = is_equal && self.proc_compare(lhs.blk_type, rhs.blk_type)
+        elsif lhs.blk_type || rhs.blk_type
+          is_equal = false
+        end
+        is_equal = is_equal && self.compare(lhs.ret_type, rhs.ret_type)
+      end 
+      return is_equal
+    end
+
+		# 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|
+        if self.compare(t, t2)
+          exist = true
+          break
+        end
+      end
+      return exist
+    end
+    
+    # This method compares two OR or MethodListType. The order of inner
+    # types do not matter.
+		#
+		# 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
+        is_equal = true
+        lhs.types.each { |t|
+          if !self.type_in_types?(t, rhs.types)
+            is_equal = false
+            break
+          end
+        }
+      end
+      return is_equal
+    end
+
+		# This method compares a method list to another method list.
+    def self.meth_list_compare(lhs, rhs)
+      return self.or_compare(lhs, rhs)
+    end
+    
+    public
+    
+    # This equal method determines whether two types are *syntactically*
+    # equivalent. Note that this is NOT a type equivalent check.
+    def self.compare(lhs,rhs)
+      if lhs == rhs
+        is_equal = true
+      elsif lhs.class != rhs.class 
+        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?(DuckType)
+        is_equal = duck_compare(lhs,rhs)
+      elsif lhs.instance_of?(FusionType)
+        is_equal = self.compare(lhs.nom_type, rhs.nom_type)        
+        if is_equal # do more testing
+          is_equal = duck_compare(lhs,rhs)
+        end
+      elsif lhs.instance_of?(MethodType)
+        is_equal = lhs.meth_name == rhs.meth_name
+        if is_equal # then do more testing
+          is_equal = self.proc_compare(lhs,rhs)
+        end
+      elsif lhs.instance_of?(BlockType)
+        is_equal = self.proc_compare(lhs,rhs)
+      elsif lhs.instance_of?(MethodListType)
+        is_equal = self.meth_list_compare(lhs,rhs)
+      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)
+      elsif lhs.instance_of?(OptionalType)
+				is_equal = rhs.instance_of?(OptionalType) &&
+									 self.compare(lhs.type, rhs.type)
+      else
+        is_equal = lhs.class == rhs.class
+      end
+      return is_equal
+    end
+
+  end
+
+  class TypeDefs::Type
+
+    # This method compares this object to another object syntactically.
+    def eql?(other)
+      TypeComparer.compare(self, other)
+    end
+  end 
+end

data/lib/rubybreaker/type/type_grammar.treetop

@@ -0,0 +1,285 @@
+#--
+# This file contains the grammar of the RubyBreaker type annotation language.
+# TODO: This file probably needs more documentation
+
+require "treetop"
+require "#{File.dirname(__FILE__)}/type"
+require "#{File.dirname(__FILE__)}/type_unparser"
+
+grammar TypeGrammar
+  include RubyBreaker
+
+  rule meth_type 
+    space? meth_name space? '(' space? arg_types_opt:(arg_types)? space? ')' 
+    space? blk_type_opt:(blk_type)? space? '->' space? ret_type space?   
+    {
+      def value
+        mname = meth_name.text_value
+        args = arg_types_opt.empty? ? [] : arg_types_opt.value
+        blk = blk_type_opt.empty? ? nil : blk_type_opt.value
+        ret = ret_type.value
+        pos = RubyBreaker::Position.get()
+        pos.col = meth_name.interval.first
+		    return RubyBreaker::MethodType.new(mname,args,blk,ret,pos)
+		  end
+    }
+  end
+  
+  rule arg_types
+    moretypes:( arg_type space? ',' space? )* 
+    rest_arg_types
+    {
+      def value
+        types = []
+        moretypes.elements.each {|t| types << t.arg_type.value  }
+        if rest_arg_types.value.kind_of?(Array) 
+          types.concat(rest_arg_types.value)
+        else
+          types << rest_arg_types.value
+        end
+        return types
+      end
+    }
+  end
+
+  rule arg_type
+    or_type / or_parent_type / fusion_type / duck_type / simple_type
+  end
+
+  rule unambig_arg_type
+    or_parent_type / fusion_type / duck_type / simple_type
+  end
+
+  rule rest_arg_types
+    opt_varlen_types / opt_types / arg_type
+  end
+
+  rule opt_types
+    moretypes:( opt_type space? ',' space? )* opt_type
+    {
+      def value
+        types = []
+        moretypes.elements.each {|t| types << t.opt_type.value }
+        types << opt_type.value
+        return types
+      end
+    }
+  end
+
+  rule opt_varlen_types
+    moretypes:( opt_type space? ',' space? )* varlen_type
+    {
+      def value
+        types = []
+        moretypes.elements.each {|t| types << t.opt_type.value }
+        types << varlen_type.value
+        return types
+      end
+    }
+  end
+
+  rule opt_type
+    unambig_arg_type '?'
+    {
+      def value
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::OptionalType.new(unambig_arg_type.value, pos)
+      end
+    }
+  end
+
+  rule varlen_type
+    unambig_arg_type '*'
+    {
+      def value
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::VarLengthType.new(unambig_arg_type.value, pos)
+      end
+    }
+  end
+
+  rule or_parent_type
+    '(' or_type ')'
+    {
+      def value(); or_type.value; end
+    }
+  end
+  
+  rule or_type
+    left:(fusion_type / duck_type / simple_type) space? 
+    more:(space? '||' space? opt:(fusion_type / duck_type / simple_type) )+
+    {
+      def value
+        types = [left.value]
+        # let's flatten the types instead of nesting them
+        more.elements.each do |t|
+          types << t.opt.value
+        end
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::OrType.new(types, pos)
+      end
+    }
+  end
+  
+  rule blk_type 
+    blk_type_empty / blk_type_full
+  end
+  
+  rule blk_type_empty
+    '{' space? '}'
+    {
+      def value
+        return nil
+      end
+    }
+  end
+  
+  rule blk_type_full
+    '{' space? '|' space? arg_types_opt:(arg_types)? space? '|' space? 
+    blk_type_opt:(blk_type)? space? '->' space? ret_type '}' 
+    {
+      def value
+        args = arg_types_opt.empty? ? [] : arg_types_opt.value
+        blk = blk_type_opt.empty? ? nil : blk_type_opt.value
+        ret = ret_type.value        
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::BlockType.new(args,blk,ret,pos)
+      end
+    }
+  end
+  
+  rule fusion_type
+    simple_type '[' space? meth_name_list space? ']'
+    {
+      def value      
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::FusionType.new(simple_type.value, meth_name_list.value,pos)
+      end
+    }
+  end
+  
+  rule duck_type
+    '[' space? meth_name_list_opt:(meth_name_list)? space? ']'
+    {
+      def value      
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        if meth_name_list_opt.empty?
+          t = RubyBreaker::AnyType.new(pos)
+        else
+          mnames = meth_name_list_opt.value
+          t = RubyBreaker::DuckType.new(mnames,pos)
+        end
+        return t
+      end 
+    }
+  end
+  
+  rule meth_name_list
+    more_meth_names:(meth_name space? ',' space?)* meth_name
+    {
+      def value
+        mnames = []
+        more_meth_names.elements.each do |more_mname|
+          mnames << more_mname.meth_name.text_value
+        end
+        mnames << meth_name.text_value
+        return mnames
+      end 
+    }
+  end
+
+  rule ret_type
+    more:(simple_type space? ',' space?)* simple_type
+    {
+      def value
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        if more.empty?
+          return simple_type.value
+        else
+          types = []
+          more.elements.each {|e| types << e.simple_type.value  }
+          types << simple_type.value
+          return types
+        end
+      end
+    }
+  end
+
+  rule simple_type
+    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 nominal_type
+    [a-z_]+ {
+      def value      
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        begin 
+          mod_name = RubyBreaker::Utilities.camelize(text_value)
+          mod = eval mod_name
+          t = RubyBreaker::NominalType.new(mod,pos)
+        rescue
+          t = RubyBreaker::AnyType.new(pos)
+        end
+        return t # RubyBreaker::NominalType.new(text_value,pos)
+      end
+    }
+  end
+  
+  rule nil_type
+    'nil' {
+      def value
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::NilType.new(pos)
+      end
+    }
+  end
+  
+  rule any_type1
+    '?' {
+      def value
+        pos = RubyBreaker::Position.get()
+        pos.col = interval.first
+        return RubyBreaker::AnyType.new(pos)
+      end
+    }
+  end
+  
+  rule 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
+
+end

data/lib/rubybreaker/type/type_unparser.rb

@@ -0,0 +1,142 @@
+#--
+# This file contains the type unparser for the type structure used in
+# RubyBreaker. No visitor pattern is used due to its "functional" element.
+# Instead, it will rely on type matches and work each type in a conditional
+# statement. 
+
+require_relative "type"
+
+module RubyBreaker
+
+  # This module prints the RubyBreaker types in a user-friendly way.
+  module TypeUnparser
+
+    include TypeDefs
+
+    private
+
+    # This method is used to determine if the inner type of +t+ should be
+    # wrapped around a parenthesis. This is for optional type and variable
+    # length type.
+    def self.peek_and_unparse_pp_inner_type(pp,t)
+      if t.type.kind_of?(OrType)
+        pp.text("(")
+        self.unparse_pp(pp,t.type)
+        pp.text(")")
+      else
+        self.unparse_pp(pp,t.type)
+      end
+    end
+
+    # This method unparses an object type (a duck type or fusion type)
+    def self.unparse_pp_object_type(pp,t)
+      pp.text("[#{t.meth_names.sort.join(", ")}]")
+    end
+
+    # This recursive method unparses a RubyBreaker type using the pretty
+    # print method.
+    def self.unparse_pp(pp,t)
+      if t.instance_of?(NominalType)
+        tname = Utilities.underscore(t.mod)
+        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?(DuckType)
+        unparse_pp_object_type(pp,t)
+      elsif t.instance_of?(FusionType)
+        unparse_pp(pp,t.nom_type)
+        unparse_pp_object_type(pp,t)
+      elsif t.instance_of?(MethodType)
+        pp.text("#{t.meth_name}(")
+        t.arg_types.each_with_index do |arg_type,i|
+          unparse_pp(pp,arg_type)
+          if i < t.arg_types.size - 1
+            pp.text(",")
+            pp.fill_breakable()
+          end 
+        end
+        pp.text(")")
+        pp.fill_breakable()
+        if t.blk_type
+          pp.text("{")
+          unparse_pp(pp,t.blk_type)
+          pp.text("}")
+          pp.fill_breakable()
+        end
+        pp.text("->")
+        pp.fill_breakable()
+        unparse_pp(pp,t.ret_type)
+      elsif t.instance_of?(BlockType)
+        pp.text("|")
+        t.arg_types.each_with_index do |arg_type,i|
+          unparse_pp(pp,arg_type)
+          if i < t.arg_types.size - 1
+            pp.text(",")
+            pp.fill_breakable()
+          end 
+        end
+        pp.text("|")
+        pp.fill_breakable()
+        if t.blk_type
+          pp.text("{")
+          unparse_pp(pp,t.blk_type)
+          pp.text("}")
+          pp.fill_breakable()
+        end
+        pp.text("->")
+        pp.fill_breakable()
+        unparse_pp(pp,t.ret_type)
+      elsif t.instance_of?(MethodListType)
+        t.types.each_with_index do |typ,i|
+          unparse_pp(pp,typ)
+          if i < t.types.size - 1 
+            pp.fill_breakable()
+          end
+        end
+      elsif t.instance_of?(OrType)
+        t.types.each_with_index do |typ,i|
+          unparse_pp(pp,typ)
+          if i < t.types.size - 1
+            pp.text(" ||")
+            pp.fill_breakable()
+          end
+        end
+      elsif t.instance_of?(OptionalType)
+        peek_and_unparse_pp_inner_type(pp,t)
+        pp.text("?")
+      elsif t.instance_of?(VarLengthType)
+        peek_and_unparse_pp_inner_type(pp,t)
+        pp.text("*")
+      elsif t.instance_of?(NilType)
+        pp.text("nil")
+      elsif t.instance_of?(AnyType)
+        pp.text("?")
+      else
+      end
+    end
+
+    public
+
+    # This method is used to display any RubyBreaker type in a user-friendly
+    # way using the pretty print method. 
+    def self.unparse(t)
+      str = ""
+      pp = PrettyPrint.new(str)
+      self.unparse_pp(pp,t)
+      pp.flush
+      return str.strip()
+    end
+  end
+
+  class TypeDefs::Type
+
+    # This method unparses the type using the pretty print method.
+    def unparse()
+      TypeUnparser.unparse(self)
+    end
+  end
+
+end
+

data/lib/rubybreaker/type.rb

@@ -0,0 +1,2 @@
+require_relative "type/type"
+require_relative "type/type_unparser"

data/lib/rubybreaker/typing/rubytype.rb

@@ -0,0 +1,47 @@
+#--
+# This file provides utility functions that deal with actual Ruby types 
+# directly. Subclass/submodule relationship is based on the inclusion of
+# the class or the module...and not the true (theoretical) subtype 
+# relationship.
+
+module RubyBreaker
+  
+  module RubyTypeUtils
+    
+    # Checks if lhs is a sub-module of rhs
+    def self.submodule_rel?(lhs,rhs)
+      # both lhs and rhs must be modules
+      if lhs == rhs 
+        return true
+      else
+        lhs.included_modules.each {|m|
+          return true if self.submodule_rel?(m,rhs)
+        }
+      end 
+      return false
+    end
+    
+    # Checks if lhs is a subclass of rhs
+    def self.subclass_rel?(lhs, rhs)
+      return false unless lhs.kind_of?(Class)
+      if lhs == rhs
+        return true
+      elsif lhs == BasicObject 
+        # lhs != rhs and no more to look upward, so quit 
+        return false
+      elsif rhs.instance_of?(Module)
+        # lhs != rhs and rhs is a module, so lhs must have a parent module 
+        # that is a subclass of rhs
+        lhs.included_modules.each {|m|
+          return true if self.submodule_rel?(m,rhs)
+        }
+      else
+        # then rhs is a class, so just go up as a class
+        return self.subclass_rel?(lhs.superclass, rhs)
+      end
+      return false
+    end
+    
+  end
+  
+end