rdl 1.0.0 → 1.0.1.rc1

data/lib/rdl/types/singleton.rb

@@ -6,7 +6,7 @@ module RDL::Type
 
     @@cache = {}
     @@cache.compare_by_identity
-    
+
     class << self
       alias :__new__ :new
     end
@@ -30,6 +30,12 @@ module RDL::Type
       return (other.instance_of? self.class) && (other.val.equal? @val)
     end
 
+    def match(other)
+      other = other.type if other.instance_of? AnnotatedArgType
+      return true if other.instance_of? WildQuery
+      return self == other
+    end
+
     def hash # :nodoc:
       return @val.hash
     end
@@ -38,7 +44,8 @@ module RDL::Type
       if @val.instance_of? Symbol
         ":{@val}"
       else
-        "Singleton(#{@val.to_s})"
+        @val.to_s
+#        "Singleton(#{@val.to_s})"
       end
     end
 
@@ -54,7 +61,7 @@ module RDL::Type
       return t <= self if t
       obj.nil? || obj.equal?(@val)
     end
-    
+
     def instantiate(inst)
       return self
     end

data/lib/rdl/types/structural.rb

@@ -52,11 +52,11 @@ module RDL::Type
       return t <= self if t
       return NominalType.new(obj.class) <= self
     end
-    
+
     def instantiate(inst)
       StructuralType.new(Hash[*@methods.each_pair.map { |m, t| [m, t.instantiate(inst)] }.flatten])
     end
-    
+
     def eql?(other)
       self == other
     end
@@ -65,6 +65,13 @@ module RDL::Type
       return (other.instance_of? StructuralType) && (other.methods == @methods)
     end
 
+    def match(other)
+      other = other.type if other.instance_of? AnnotatedArgType
+      return true if other.instance_of? WildQuery
+      return (@methods.length == other.methods.length &&
+              @methods.all? { |k, v| (other.methods.has_key? k) && (v.match(other.methods[k]))})
+    end
+
     def hash  # :nodoc:
       @methods.hash
     end

data/lib/rdl/types/top.rb

@@ -24,11 +24,17 @@ module RDL::Type
     def eql?(other)
       self == other
     end
-      
+
     def ==(other)
       other.instance_of? TopType
     end
 
+    def match(other)
+      other = other.type if other.instance_of? AnnotatedArgType
+      return true if other.instance_of? WildQuery
+      return self == other
+    end
+
     def <=(other)
       other.instance_of? TopType
     end
@@ -38,11 +44,11 @@ module RDL::Type
       return t <= self if t
       true
     end
-    
+
     def instantiate(inst)
       return self
     end
-    
+
     def hash
       17
     end

data/lib/rdl/types/tuple.rb

@@ -14,7 +14,7 @@ module RDL::Type
     def self.new(*params)
       t = @@cache[params]
       return t if t
-      raise RuntimeError, "Attempt to create generic type with non-type param" unless params.all? { |p| p.is_a? Type }
+      raise RuntimeError, "Attempt to create tuple type with non-type param" unless params.all? { |p| p.is_a? Type }
       t = TupleType.__new__(params)
       return (@@cache[params] = t) # assignment evaluates to t
     end
@@ -36,13 +36,19 @@ module RDL::Type
       return (other.instance_of? TupleType) && (other.params == @params)
     end
 
+    def match(other)
+      other = other.type if other.instance_of? AnnotatedArgType
+      return true if other.instance_of? WildQuery
+      return @params.length == other.params.length && @params.zip(other.params).all? { |t,o| t.match(o) }
+    end
+
     def <=(other)
       return true if other.instance_of? TopType
       return self == other
       # Subtyping with Array not allowed
       # All positions of Tuple are invariant since tuples are mutable
     end
-    
+
     def member?(obj, *args)
       t = RDL::Util.rdl_type obj
       return t <= self if t
@@ -53,7 +59,7 @@ module RDL::Type
     def instantiate(inst)
       TupleType.new(*@params.map { |t| t.instantiate(inst) })
     end
-    
+
     def hash
       h = 73 * @params.hash
     end

data/lib/rdl/types/type_query.rb

@@ -0,0 +1,5 @@
+module RDL::Type
+  class TypeQuery < Type
+
+  end
+end

data/lib/rdl/types/union.rb

@@ -3,7 +3,7 @@ require_relative 'type'
 module RDL::Type
   class UnionType < Type
     attr_reader :types
-    
+
     @@cache = {}
 
     class << self
@@ -26,7 +26,7 @@ module RDL::Type
         end
       }
 
-      ts.sort! { |a,b| a.object_id <=> b.object_id }      
+      ts.sort! { |a,b| a.object_id <=> b.object_id }
       ts.uniq!
 
       return NilType.new if ts.size == 0
@@ -55,6 +55,13 @@ module RDL::Type
       return (other.instance_of? UnionType) && (other.types == @types)
     end
 
+    def match(other)
+      other = other.type if other.instance_of? AnnotatedArgType
+      return true if other.instance_of? WildQuery
+      return false if @types.length != other.types.length
+      @types.all? { |t| other.types.any? { |ot| t.match(ot) } }
+    end
+
     def <=(other)
       @types.all? { |t| t <= other }
     end
@@ -62,11 +69,11 @@ module RDL::Type
     def member?(obj, *args)
       @types.any? { |t| t.member?(obj, *args) }
     end
-    
+
     def instantiate(inst)
       return UnionType.new(*(@types.map { |t| t.instantiate(inst) }))
     end
-    
+
     def hash  # :nodoc:
       41 + @types.hash
     end

data/lib/rdl/types/var.rb

@@ -34,6 +34,12 @@ module RDL::Type
       return (other.instance_of? self.class) && (other.name.to_s == @name.to_s)
     end
 
+    def match(other)
+      other = other.type if other.instance_of? AnnotatedArgType
+      return true if other.instance_of? WildQuery
+      return self == other
+    end
+
     def hash # :nodoc:
       return @name.to_s.hash
     end

data/lib/rdl/types/vararg.rb

@@ -41,12 +41,18 @@ module RDL::Type
       return (other.instance_of? VarargType) && (other.type == @type)
     end
 
+    def match(other)
+      other = other.type if other.instance_of? AnnotatedArgType
+      return true if other.instance_of? WildQuery
+      return (other.instance_of? VarargType) && (@type.match(other.type))
+    end
+
     # Note: no member?, because these can only appear in MethodType, where they're handled specially
-    
+
     def instantiate(inst)
       return VarargType.new(@type.instantiate(inst))
     end
-    
+
     def hash # :nodoc:
       return 59 + @type.hash
     end

data/lib/rdl/types/wild_query.rb

@@ -0,0 +1,28 @@
+require_relative 'type_query'
+
+module RDL::Type
+  class WildQuery < TypeQuery
+    @@cache = nil
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new
+      @@cache = WildQuery.__new__ unless @@cache
+      return @@cache
+    end
+
+    def to_s
+      "*"
+    end
+
+    def ==(other)
+      return (other.instance_of? WildQuery)
+    end
+
+    def match(other)
+      return true
+    end
+  end
+end

data/lib/rdl/util.rb

@@ -1,4 +1,8 @@
 class RDL::Util
+
+  SINGLETON_MARKER = "[s]"
+  SINGLETON_MARKER_REGEXP = Regexp.escape(SINGLETON_MARKER)
+
   def self.to_class(klass)
     return klass if klass.class == Class
     if has_singleton_marker(klass)
@@ -11,11 +15,11 @@ class RDL::Util
   end
 
   def self.has_singleton_marker(klass)
-    return (klass =~ /^\[singleton\]/)
+    return (klass =~ /^#{SINGLETON_MARKER_REGEXP}/)
   end
-  
+
   def self.remove_singleton_marker(klass)
-    if klass =~ /^\[singleton\](.*)/
+    if klass =~ /^#{SINGLETON_MARKER_REGEXP}(.*)/
       return $1
     else
       return nil
@@ -23,9 +27,18 @@ class RDL::Util
   end
 
   def self.add_singleton_marker(klass)
-    return "[singleton]" + klass
+    return SINGLETON_MARKER + klass
+  end
+
+  # Klass should be a string and may have a singleton marker
+  def self.pretty_name(klass, meth)
+    if klass =~ /^#{SINGLETON_MARKER_REGEXP}(.*)/
+      return "#{$1}.#{meth}"
+    else
+      return "#{klass}##{meth}"
+    end
   end
-    
+
   def self.method_defined?(klass, method)
     begin
       (self.to_class klass).method_defined?(method.to_sym) ||

data/lib/rdl/wrap.rb

@@ -418,7 +418,7 @@ class Object
       raise RuntimeError, "Receiver is of class #{klass}, which is not parameterized" unless formals
       raise RuntimeError, "Expecting #{params.size} type parameters, got #{typs.size}" unless formals.size == typs.size
       raise RuntimeError, "Instance already has type instantiation" if @__rdl_type
-      new_typs = typs.map { |t| if t.is_a? RDL::Type::Type then t else $__rdl_parser.scan_str "## #{t}" end }
+      new_typs = typs.map { |t| if t.is_a? RDL::Type::Type then t else $__rdl_parser.scan_str "#T #{t}" end }
       t = RDL::Type::GenericType.new(RDL::Type::NominalType.new(klass), *new_typs)
       if all.instance_of? Symbol
         self.send(all) { |*objs|
@@ -451,7 +451,7 @@ class Object
   # Returns a new object that wraps self in a type cast. This cast is *unchecked*, so use with caution
   def type_cast(typ)
     $__rdl_contract_switch.off {
-      new_typ = if typ.is_a? RDL::Type::Type then typ else $__rdl_parser.scan_str "## #{typ}" end
+      new_typ = if typ.is_a? RDL::Type::Type then typ else $__rdl_parser.scan_str "#T #{typ}" end
       obj = SimpleDelegator.new(self)
       obj.instance_variable_set('@__rdl_type', new_typ)
       return obj
@@ -467,7 +467,7 @@ class Object
       raise RuntimeError, "Attempt to redefine type #{name}" if $__rdl_special_types[name]
       case typ
       when String
-        t = $__rdl_parser.scan_str "## #{typ}"
+        t = $__rdl_parser.scan_str "#T #{typ}"
         $__rdl_special_types[name] = t
       when RDL::Type::Type
         $__rdl_special_types[name] = typ
@@ -476,38 +476,4 @@ class Object
       end
     }
   end
-
-  def rdl_query(q)
-    $__rdl_contract_switch.off {
-      if q =~ /^(\w+(#|\.))?(\w+(!|\?|=)?|!|~|\+|\*\*|-|\*|\/|%|<<|>>|&|\||\^|<|<=|=>|>|==|===|!=|=~|!~|<=>|\[\]|\[\]=)$/
-        klass = nil
-        klass_pref = nil
-        meth = nil
-        if q =~ /(.+)#(.+)/
-          klass = $1
-          klass_pref = "#{klass}#"
-          meth = $2.to_sym
-        elsif q =~ /(.+)\.(.+)/
-          klass_pref = "#{$1}."
-          klass = RDL::Util.add_singleton_marker($1)
-          meth = $2.to_sym
-        else
-          klass = self.class.to_s
-          klass_pref = "#{klass}#"
-          meth = q.to_sym
-        end
-        if RDL::Wrap.has_contracts?(klass, meth, :type)
-          typs = RDL::Wrap.get_contracts(klass, meth, :type)
-          typs.each { |t|
-            puts "#{klass_pref}#{meth}: #{t}"
-          }
-          nil
-        else
-          puts "No type for #{klass_pref}#{meth}"
-        end
-      else
-        puts "Not implemented"
-      end
-    }
-  end
 end

data/rdl.gemspec

@@ -4,8 +4,8 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '1.0.0'
-  s.date        = '2015-12-18'
+  s.version     = '1.0.1.rc1'
+  s.date        = '2016-01-01'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
 RDL is a gem that allows contracts (pre- and postconditions) to be added to methods.
@@ -17,6 +17,7 @@ EOF
   s.authors     = ['Jeffrey S. Foster', 'Brianna M. Ren', 'T. Stephen Strickland', 'Alexander T. Yu']
   s.email       = ['rdl-users@googlegroups.com']
   s.files       = `git ls-files`.split($/)
+  s.executables << 'rdl_query'
   s.homepage    = 'https://github.com/plum-umd/rdl'
   s.license     = 'BSD-3-Clause'
   s.add_runtime_dependency 'require_all', '~> 1.3', '>= 1.3.3'

data/test/test_parser.rb

@@ -72,16 +72,16 @@ class TestParser < Minitest::Test
   end
 
   def test_bare
-    t1 = @p.scan_str "## nil"
+    t1 = @p.scan_str "#T nil"
     assert_equal @tnil, t1
-    t2 = @p.scan_str "## %any"
+    t2 = @p.scan_str "#T %any"
     assert_equal @ttop, t2
-    t3 = @p.scan_str "## A"
+    t3 = @p.scan_str "#T A"
     assert_equal NominalType.new("A"), t3
   end
 
   def test_symbol
-    t1 = @p.scan_str "## :symbol"
+    t1 = @p.scan_str "#T :symbol"
     assert_equal @tsymbol, t1
   end
 
@@ -109,66 +109,66 @@ class TestParser < Minitest::Test
   end
 
   def test_generic
-    t1 = @p.scan_str "## t"
+    t1 = @p.scan_str "#T t"
     assert_equal (VarType.new "t"), t1
-    t2 = @p.scan_str "## Array"
+    t2 = @p.scan_str "#T Array"
     assert_equal (NominalType.new "Array"), t2
-    t3 = @p.scan_str "## Array<t>"
+    t3 = @p.scan_str "#T Array<t>"
     assert_equal (GenericType.new(t2, t1)), t3
-    t4 = @p.scan_str "## Array<Array<t>>"
+    t4 = @p.scan_str "#T Array<Array<t>>"
     assert_equal (GenericType.new(t2, t3)), t4
-    t5 = @p.scan_str "## Hash"
+    t5 = @p.scan_str "#T Hash"
     assert_equal (NominalType.new "Hash"), t5
-    t6 = @p.scan_str "## Hash<u, v>"
+    t6 = @p.scan_str "#T Hash<u, v>"
     assert_equal (GenericType.new(t5, VarType.new("u"), VarType.new("v"))), t6
-    t7 = @p.scan_str "## Foo<String, Array<t>, Array<Array<t>>>"
+    t7 = @p.scan_str "#T Foo<String, Array<t>, Array<Array<t>>>"
     assert_equal (GenericType.new(NominalType.new("Foo"), @tstring, t3, t4)), t7
   end
 
   def test_tuple
-    t1 = @p.scan_str "## [Fixnum, String]"
+    t1 = @p.scan_str "#T [Fixnum, String]"
     assert_equal (TupleType.new(@tfixnum, @tstring)), t1
-    t2 = @p.scan_str "## [String]"
+    t2 = @p.scan_str "#T [String]"
     assert_equal (TupleType.new(@tstring)), t2
-  end 
+  end
 
   def test_fixnum
-    t1 = @p.scan_str "## 42"
+    t1 = @p.scan_str "#T 42"
     assert_equal (SingletonType.new(42)), t1
-    t2 = @p.scan_str "## -42"
+    t2 = @p.scan_str "#T -42"
     assert_equal (SingletonType.new(-42)), t2
   end
 
   def test_float
-    t1 = @p.scan_str "## 3.14"
+    t1 = @p.scan_str "#T 3.14"
     assert_equal (SingletonType.new(3.14)), t1
   end
 
   def test_const
-    t1 = @p.scan_str "## ${Math::PI}"
+    t1 = @p.scan_str "#T ${Math::PI}"
     assert_equal (SingletonType.new(Math::PI)), t1
   end
 
   def test_type_alias
     type_alias '%foobarbaz', @tnil
-    assert_equal @tnil, (@p.scan_str "## %foobarbaz")
+    assert_equal @tnil, (@p.scan_str "#T %foobarbaz")
     type_alias '%quxquxqux', 'nil'
-    assert_equal @tnil, (@p.scan_str "## %quxquxqux")
+    assert_equal @tnil, (@p.scan_str "#T %quxquxqux")
     assert_raises(RuntimeError) { type_alias '%quxquxqux', 'nil' }
-    assert_raises(RuntimeError) { @p.scan_str "## %qux" }
+    assert_raises(RuntimeError) { @p.scan_str "#T %qux" }
   end
 
   def test_structural
-    t1 = @p.scan_str "## [to_str: () -> String]"
+    t1 = @p.scan_str "#T [to_str: () -> String]"
     tm1 = MethodType.new [], nil, @tstring
     ts1 = StructuralType.new(to_str: tm1)
     assert_equal ts1, t1
   end
 
   def test_finite_hash
-    t1 = @p.scan_str "## {a: Fixnum, b: String}"
+    t1 = @p.scan_str "#T {a: Fixnum, b: String}"
     assert_equal (FiniteHashType.new({a: @tfixnum, b: @tstring})), t1
-    t2 = @p.scan_str "## {'a'=>Fixnum, 2=>String}"
+    t2 = @p.scan_str "#T {'a'=>Fixnum, 2=>String}"
     assert_equal (FiniteHashType.new({"a"=>@tfixnum, 2=>@tstring})), t2
   end