rdl 2.0.0.rc4 → 2.0.0.rc5

data/lib/rdl/types/type.rb

@@ -25,9 +25,9 @@ module RDL::Type
     end
 
     # default behavior, override in appropriate subclasses
-    def canonical
-      return self
-    end
+    def canonical; return self; end
+    def optional?; return false; end
+    def vararg?; return false; end
 
     # [+ other +] is a Type
     # [+ inst +] is a Hash<Symbol, Type> representing an instantiation
@@ -143,6 +143,7 @@ module RDL::Type
           return false # one has a block and the other doesn't
         end
       end
+      return true if left.is_a?(MethodType) && right.is_a?(NominalType) && right.name == 'Proc'
 
       # structural
       if left.is_a?(StructuralType) && right.is_a?(StructuralType)
@@ -175,18 +176,26 @@ module RDL::Type
       if left.is_a?(FiniteHashType) && right.is_a?(FiniteHashType)
         # Like Tuples, FiniteHashes are immutable, so covariant subtyping allowed
         # But note, no width subtyping allowed, to match #member?
-        rest = right.elts.clone # shallow copy
+        right_elts = right.elts.clone # shallow copy
         left.elts.each_pair { |k, tl|
-          return false unless rest.has_key? k
-          tr = rest[k]
-          tl = tl.type if tl.is_a? OptionalType
-          tr = tr.type if tr.is_a? OptionalType
-          return false unless leq(tl, tr, inst, ileft)
-          rest.delete k
+          if right_elts.has_key? k
+            tr = right_elts[k]
+            return false if tl.is_a?(OptionalType) && !tr.is_a?(OptionalType) # optional left, required right not allowed, since left may not have key
+            tl = tl.type if tl.is_a? OptionalType
+            tr = tr.type if tr.is_a? OptionalType
+            return false unless leq(tl, tr, inst, ileft)
+            right_elts.delete k
+          else
+            return false unless right.rest && leq(tl, right.rest, inst, ileft)
+          end
         }
-        rest.each_pair { |k, t|
+        right_elts.each_pair { |k, t|
           return false unless t.is_a? OptionalType
         }
+        unless left.rest.nil?
+          # If left has optional stuff, right needs to accept it
+          return false unless !(right.rest.nil?) && leq(left.rest, right.rest, inst, ileft)
+        end
         left.ubounds << right
         right.lbounds << left
         return true

data/lib/rdl/types/union.rb

@@ -15,6 +15,9 @@ module RDL::Type
           ts.concat t.types
         else
           raise RuntimeError, "Attempt to create union type with non-type" unless t.is_a? Type
+          raise RuntimeError, "Attempt to create union with optional type" if t.is_a? OptionalType
+          raise RuntimeError, "Attempt to create union with vararg type" if t.is_a? VarargType
+          raise RuntimeError, "Attempt to create union with annotated type" if t.is_a? AnnotatedArgType
           ts << t
         end
       }

data/lib/rdl/types/vararg.rb

@@ -17,8 +17,9 @@ module RDL::Type
     end
 
     def initialize(type)
-      raise "Can't have vararg optional type" if type.class == OptionalType
-      raise "Can't have vararg vararg type" if type.class == VarargType
+      raise "Can't have vararg optional type" if type.is_a? OptionalType
+      raise "Can't have vararg vararg type" if type.is_a? VarargType
+      raise "Can't have optional annotated type" if type.is_a? AnnotatedArgType
       @type = type
       super()
     end
@@ -55,5 +56,9 @@ module RDL::Type
     def hash # :nodoc:
       return 59 + @type.hash
     end
+
+    def vararg?
+      return true
+    end
   end
 end

data/lib/rdl/wrap.rb

@@ -535,13 +535,26 @@ class Object
     nil
   end
 
-  # Type check all methods that had annotation `typecheck: sym' at type call
+  # Register [+ blk +] to be executed when `rdl_do_typecheck [+ sym +]` is called.
+  # The blk will be called with sym as its argument. The order
+  # in which multiple blks for the same sym will be executed is unspecified
+  def rdl_at(sym, &blk)
+    $__rdl_at[sym] = [] unless $__rdl_at[sym]
+    $__rdl_at[sym] << blk
+  end
+
+  # Invokes all callbacks from rdl_at(sym), in unspecified order.
+  # Afterwards, type checks all methods that had annotation `typecheck: sym' at type call, in unspecified order.
   def rdl_do_typecheck(sym)
+    if $__rdl_at[sym]
+      $__rdl_at[sym].each { |blk| blk.call(sym) }
+    end
+    $__rdl_at[sym] = Array.new
     return unless $__rdl_to_typecheck[sym]
     $__rdl_to_typecheck[sym].each { |klass, meth|
       RDL::Typecheck.typecheck(klass, meth)
     }
-    $__rdl_to_typecheck[sym] = Array.new
+    $__rdl_to_typecheck[sym] = Set.new
     nil
   end
 

data/lib/types/core-ruby-2.x/proc.rb

@@ -0,0 +1,16 @@
+class Proc
+  rdl_nowrap
+
+  type :arity, '() -> %integer'
+  type :binding, '() -> Binding'
+  type :curry, '(?%integer arity) -> Proc'
+  type :hash, '() -> %integer'
+  rdl_alias :inspect, :to_s
+  type :lambda, '() -> %bool'
+  type :parameters, '() -> Array<[Symbol, Symbol]>'
+  type :source_location, '() -> [String, %integer]'
+  type :to_proc, '() -> self'
+  type :to_s, '() -> String'
+
+
+end

data/lib/types/rails-5.x/_helpers.rb

@@ -1,6 +1,8 @@
 # :integer, :bigint, :float, :decimal, :numeric, :datetime, :time, :date, :binary, :boolean.
 # null allowed
 
+type_alias '%symstr', 'Symbol or String'
+
 module RDL
   class Rails
 
@@ -28,5 +30,23 @@ module RDL
         raise RuntimeError, "Unrecoganized column type #{rails_type}"
       end
     end
+
+    # [+ model +] is an ActiveRecord::Base subclass that has been loaded.
+    # Gets the columns_hash of the model and returns a String that can
+    # serve as the paramter list to a method that accepts any number
+    # of the model's attributes keyed by the attribute names.
+    def self.attribute_types(model)
+      args = []
+
+      model.columns_hash.each { |name, col|
+        t = column_to_rdl(col.type)
+        if col.null
+          args << "#{name}: ?#{t}"
+        else
+          args << "#{name}: ?!#{t}"
+        end
+      }
+      return args.join ','
+    end
   end
 end

data/lib/types/rails-5.x/active_model/errors.rb

@@ -0,0 +1,15 @@
+class ActiveModel::Errors
+  type :clear, '() -> %any'
+  type :delete, '(%symstr) -> %any'
+  type :[], '(%symstr) -> Array<String>'
+  type :each, '() { (%symstr, String) -> %any } -> %any'
+  type :size, '() -> %integer'
+  rdl_alias :count, :size
+  type :values, '() -> Array<String>'
+  type :keys, '() -> Array<Symbol>'
+  type :empty?, '() -> %bool'
+  rdl_alias :blank?, :empty?
+  type :hash, '(?%bool full_messages) -> Hash<Symbol, String>'
+  type :add, '(%symstr, %symstr, Hash<Symbol, %any>) -> %any'
+  type :add, '(%symstr, { () -> String }, Hash<Symbol, %any>) -> %any' # TODO: combine with prev with union once supported
+end

data/lib/types/rails-5.x/active_model/validations.rb

@@ -0,0 +1,5 @@
+module ActiveModel
+  module Validations
+    type :errors, '() -> ActiveModel::Errors'
+  end
+end

data/lib/types/rails-5.x/active_record/associations.rb

@@ -0,0 +1,190 @@
+class ActiveRecord::Associations::CollectionProxy
+  type_params [:t], :all?
+
+  type :<<, '(*(t or Array<t>)) -> self'
+  type :==, '(%any) -> %bool'
+  type :any?, '() ?{ (t) -> %bool } -> %bool'
+  rdl_alias :append, :<<
+  type :build, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
+  type :clear, '() -> self'
+  type :concat, '(*t) -> self'
+  type :count, '() -> %integer'
+  type :create, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
+  type :create!, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
+  type :delete, '(*t) -> Array<t>'
+  type :delete_all, '(?Symbol dependent) -> Array<t>'
+  type :destroy, '(*t) -> Array<t>'
+  type :destroy_all, '() -> %any'
+  type :distinct, '() -> self'
+  type :empty?, '() -> %bool'
+  type :find, '(%integer) -> t'
+  type :find, '(%integer, %integer, *%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :include?, '(t) -> %bool'
+  type :length, '() -> %integer'
+  type :load_target, '() -> %any'
+  type :loaded?, '() -> %bool'
+  type :many?, '() ?{ (t) -> %bool } -> %bool'
+  rdl_alias :new, :build
+  rdl_alias :push, :<<
+  type :reload, '() -> self'
+  type :replace, '(Array<t>) -> %any'
+  type :reset, '() -> self'
+  type :scope, '() -> ActiveRecord::Relation' # TODO fix
+  type :select, '(*Symbol) -> t'
+  type :select, '() { (t) -> %bool } -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :size, '() -> %integer'
+  rdl_alias :spawn, :scope
+  type :take, '() -> t or nil'
+  type :take, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :to_ary, '() -> Array<t>'
+  rdl_alias :to_a, :to_ary
+  rdl_alias :unique, :distinct
+
+  type :first, '() -> t or nil'
+  type :first, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :second, '() -> t or nil'
+  type :second, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :third, '() -> t or nil'
+  type :third, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :fourth, '() -> t or nil'
+  type :fourth, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :fifth, '() -> t or nil'
+  type :fifth, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :forty_two, '() -> t or nil'
+  type :forty_two, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :third_to_last, '() -> t or nil'
+  type :third_to_last, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :second_to_last, '() -> t or nil'
+  type :second_to_last, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+  type :last, '() -> t or nil'
+  type :last, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+end
+
+module ActiveRecord::Associations::ClassMethods
+
+  # TODO: Check presence of methods required by, e.g., foreign_key, primary_key, etc.
+  # TODO: Check counter_cache, add to model attr_readonly_type
+
+
+  type :belongs_to, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr, foreign_key: ?%symstr,' +
+                    'primary_key: ?%symstr, dependent: ?(:delete or :destroy), counter_cache: ?(%bool or %symstr),' +
+                    'polymorphic: ?%bool, validate: ?%bool, autosave: ?%bool, touch: ?(%bool or %symstr),' +
+                    'inverse_of: ?%symstr, optional: ?%bool, required: ?%bool, anonymous_class: ?Class) -> %any'
+
+  pre :belongs_to do |name, scope=nil, class_name: nil, foreign_key: nil, primary_key: nil,
+                      dependent: nil, counter_cache: nil, polymorphic: nil,
+                      validate: nil, autosave: nil, touch: nil, inverse_of: nil,
+                      optional: nil, required: nil, anonymous_class: nil|
+    if polymorphic
+      assoc_type = '%any' # type is data-driven, can't determine statically
+    elsif class_name
+      assoc_type = class_name.to_s.classify
+    elsif anonymous_class
+      assoc_type = anonymous_class.to_s
+    else
+      assoc_type = name.to_s.classify # camelize?
+    end
+    type name, "(?%bool force_reload) -> #{assoc_type}"
+    type "#{name}=", "(#{assoc_type}) -> #{assoc_type}"
+    unless polymorphic
+      rdl_at(:model) { |sym|
+        assoc_attribute_types = RDL::Rails.attribute_types(assoc_type.constantize)
+        type "build_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+        type "create_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+        type "create_#{name}!", "(#{assoc_attribute_types}) -> #{assoc_type}"
+      }
+    end
+    true
+  end
+
+  type :has_one, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr,'+
+                 'dependent: ?(:destroy or :delete or :nullify or :restrict_with_exception or :restrict_with_error),' +
+                 'foreign_key: ?%symstr, foreign_type: ?%symstr, primary_key: ?%symstr, as: ?%symstr,' +
+                 'through: ?%symstr, source: ?%symstr, source_type: ?%symstr, validate: ?%bool, autosave: ?%bool,' +
+                 'inverse_of: ?%symstr, required: ?%bool, anonymous_class: ?Class) -> %any'
+
+  pre :has_one do |name, scope=nil, class_name: nil, dependent: nil, foreign_key: nil,
+                   foreign_type: nil, primary_key: nil, as: nil, through: nil, source: nil,
+                   source_type: nil, vadliate: nil, autosave: nil, inverse_of: nil,
+                   required: nil|
+   if as
+     assoc_type = '%any' # type is data-driven, can't determine statically
+   elsif class_name
+     assoc_type = class_name.to_s.classify
+   elsif anonymous_class # not sure this has anonymou_class
+     assoc_type = anonymous_class.to_s.classify
+   else
+     assoc_type = name.to_s.classify # camelize?
+   end
+   type name, "(?%bool force_reload) -> #{assoc_type}"
+   type "#{name}=", "(#{assoc_type}) -> #{assoc_type}"
+   unless as
+     rdl_at(:model) { |sym|
+       assoc_attribute_types = RDL::Rails.attribute_types(assoc_type.constantize)
+       type "build_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+       type "create_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+       type "create_#{name}!", "(#{assoc_attribute_types}) -> #{assoc_type}"
+     }
+   end
+  end
+
+  type :has_many, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr,' +
+                  'foreign_key: ?%symstr, foreign_type: ?%symstr, primary_key: ?%symstr,' +
+                  'dependent: ?(:destroy or :delete_all or :nullify or :restrict_with_exception or :restrict_with_error),' +
+                  'counter_cache: ?(%bool or %symstr), as: ?%symstr, through: ?%symstr, source: ?%symstr,' +
+                  'source_type: ?%symstr, validate: ?%bool, inverse_of: ?%symstr, extend: ?(Module or Array<Module>))' +
+                  '?{ () -> %any } -> %any'
+
+  pre :has_many do |name, scope=nil, class_name: nil, foreign_key: nil, foreign_type: nil, primary_key: nil,
+                    dependent: nil, counter_cache: nil, as: nil, through: nil, source: nil, source_type: nil,
+                    validate: nil, inverse_of: nil, extend: nil|
+    if class_name
+      collect_type = class_name.to_s.classify
+    else
+      collect_type = name.to_s.singularize.classify
+    end
+    type name, "() -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>"
+    type "#{name}=", "(Array<t>) -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>" # TODO not sure of type
+    id_type = RDL::Rails.column_to_rdl(collect_type.constantize.columns_hash['id'].type) # TODO assumes id field is "id"
+    type "#{name.to_s.singularize}_ids", "() -> Array<#{id_type}>"
+    type "#{name.to_s.singularize}_ids=", "() -> Array<#{id_type}>"
+
+    true
+  end
+
+  type :has_and_belongs_to_many, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr,' +
+                                 'join_table: ?%symstr, foreign_key: ?%symstr, association_foreign_key: ?%symstr,' +
+                                 'validate: ?%bool, autosave: ?%bool) ?{ () -> %any } -> %any'
+
+  pre :has_and_belongs_to_many do |name, scope=nil, class_name: nil, join_table: nil,
+                                  foreign_key: nil, association_foreign_key: nil,
+                                  validate: nil, autosave: nil|
+    if class_name
+      collect_type = class_name.to_s.classify
+    else
+      collect_type = name.to_s.singularize.classify
+    end
+    type name, "() -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>"
+    type "#{name}=", "(Array<t>) -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>" # TODO not sure of type
+    id_type = RDL::Rails.column_to_rdl(collect_type.constantize.columns_hash['id'].type) # TODO assumes id field is "id"
+    type "#{name.to_s.singularize}_ids", "() -> Array<#{id_type}>"
+    type "#{name.to_s.singularize}_ids=", "() -> Array<#{id_type}>"
+
+    # Remaining methods are from CollectionProxy
+    # TODO give these precise types for this particular model
+    # collection<<(object, ...)
+    # collection.delete(object, ...)
+    # collection.destroy(object, ...)
+    # collection.clear
+    # collection.empty?
+    # collection.size
+    # collection.find(...)
+    # collection.where(...)
+    # collection.exists?(...)
+    # collection.build(attributes = {})
+    # collection.create(attributes = {})
+    # collection.create!(attributes = {})
+    true
+  end
+
+end

data/lib/types/rails-5.x/active_record/core.rb

@@ -0,0 +1,3 @@
+module ActiveRecord::Core
+  type :==, '(%any) -> %bool'
+end

data/lib/types/rails-5.x/active_record/model_schema.rb

@@ -2,8 +2,6 @@ module ActiveRecord
   module ModelSchema
     module ClassMethods
       post(:load_schema!) { |ret| # load_schema! doesn't return anything interesting
-        find_by_args = []
-
         columns_hash.each { |name, col|
           t = RDL::Rails.column_to_rdl(col.type)
           if col.null
@@ -13,7 +11,6 @@ module ActiveRecord
             type "write_attribute", "(:#{name}, #{t}) -> %bool"
             type "update_attribute", "(:#{name}, #{t}) -> %bool"
             type "update_column", "(:#{name}, #{t}) -> %bool"
-            find_by_args << "#{name}: ?#{t}"
           else
             # not null; can't truly check in type system but hint via the name
             type name,       "() -> !#{t}"                 # getter
@@ -21,15 +18,15 @@ module ActiveRecord
             type "write_attribute", "(:#{name}, !#{t}) -> %bool"
             type "update_attribute", "(:#{name}, #{t}) -> %bool"
             type "update_column", "(:#{name}, #{t}) -> %bool"
-            find_by_args << "#{name}: ?!#{t}"
           end
         }
-        hash_args = find_by_args.join(',')
-        type 'self.find_by', '(' + hash_args + ") -> #{self} or nil"
-        type 'self.find_by!', '(' + hash_args + ") -> #{self}"
-        type 'update', '(' + hash_args + ') -> %bool'
-        type 'update_columns', '(' + hash_args + ') -> %bool'
-        type 'attributes=', '(' + hash_args + ') -> %bool'
+
+        attribute_types = RDL::Rails.attribute_types(self)
+        type 'self.find_by', '(' + attribute_types + ") -> #{self} or nil"
+        type 'self.find_by!', '(' + attribute_types + ") -> #{self}"
+        type 'update', '(' + attribute_types + ') -> %bool'
+        type 'update_columns', '(' + attribute_types + ') -> %bool'
+        type 'attributes=', '(' + attribute_types + ') -> %bool'
 
         # If called with String arguments, can't check types as precisely
         type 'write_attribute', '(String, %any) -> %bool'

data/rdl.gemspec

@@ -4,8 +4,8 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '2.0.0.rc4'
-  s.date        = '2016-08-13'
+  s.version     = '2.0.0.rc5'
+  s.date        = '2016-08-24'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
 RDL is a gem that adds types and contracts to Ruby. RDL includes extensive

data/test/test_le.rb

@@ -168,6 +168,29 @@ class TestLe < Minitest::Test
     assert (tfs2_4 <= thfs_4) # allowed, both tfs2_4 and tfs_4 promoted to hash
     tfs3_4 = tt "{x: Fixnum, y: String}"
     assert (not(tfs_4 <= tfs3_4)) # not allowed, tfs_4 has been promoted
+
+    tfss_5 = tt "{x: Fixnum, y: String, **Symbol}"
+    tfns_5 = tt "{x: Fixnum, **Symbol}"
+    tfsn_5 = tt "{x: Fixnum, y: String}"
+    tftn_5 = tt "{x: Fixnum, z: Symbol}"
+    tooo_5 = tt "{x: Object, y: Object, **Object}"
+    tono_5 = tt "{x: Object, **Object}"
+    assert (tfss_5 <= tooo_5)
+    assert (tfns_5 <= tono_5)
+    assert (not (tfss_5 <= tfns_5))
+    assert (not (tfss_5 <= tfsn_5))
+    assert (not (tfss_5 <= tftn_5))
+    assert (not (tfns_5 <= tfss_5))
+    assert (not (tfns_5 <= tfsn_5))
+    assert (not (tfns_5 <= tftn_5))
+    assert (tfsn_5 <= tfss_5)
+    assert (not (tfsn_5 <= tfns_5))
+    assert (not (tfsn_5 <= tftn_5))
+    assert (not (tftn_5 <= tfss_5))
+    assert (tftn_5 <= tfns_5)
+    assert (not (tftn_5 <= tfsn_5))
+
+    assert (not (tt("{x: ?Fixnum}") <= tt("{x: Fixnum}")))
   end
 
   def test_method
@@ -197,6 +220,7 @@ class TestLe < Minitest::Test
     assert (not (tbos <= tbso))
     assert (tbso <= tbso)
     assert (tbso <= tbos)
+    assert (tss <= $__rdl_proc_type)
   end
 
   def test_structural