rdl 2.0.0.rc3 → 2.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12683f52b0d365695fbbddde7ab7494ae049202e
-  data.tar.gz: 67d2aaf4bde9eba67027f5bc7662fd7d7e33c746
+  metadata.gz: 036f7f5447f5a5405a0624b7f346101e19012c19
+  data.tar.gz: 3004e573e29f44e4adea3c2b1cdc314134fa4f4f
 SHA512:
-  metadata.gz: f42995d41cd05b3d9e1115c0cf7e20a4873f840659e9fd56e0f476941adac6dfef199dce88bacafdefaacbc3cf410be917fc6213b77ebe0a5428840e75721542
-  data.tar.gz: 0ee8aa838a19d9977acc2556bba2ef295bc8be97a6a6407af4a7882a2ecd62c09ef4d5b6464a61f49137d26751bd43c581df932e883424f96126847edf1606f9
+  metadata.gz: 0355d89a993299da187c096dd85b27209205a0155c80780944c88118a775e2b82f6f9746536465f8f096a8197ebfd1084f64c613f90a1319e2a31b88f5b1645a
+  data.tar.gz: db84c871660e4e4e6458d31f11bef1ed5a68056d3ac5dd8fd293e85b5b189cc9431c359c28a1db41fc3dd27244835f854aa8aa287a5873786bb0f4b7a72b72b9

data/CHANGES.md

@@ -10,9 +10,13 @@
 
 ### Changed
 - Modified `self` type to be any instance of the self's class
-- Library types now use new aliases %integer and %numeric instead of the Integer and Numeric classes.
+- Library types now use new aliases %integer and %numeric instead of the Integer and Numeric classes
+- Instead of requiring `rdl_types.rb`, require `types/core`
+
+### Fixed
 - Fix issue #14 - allow type/pre/post to coexist, improve docs on dependent types
 - Fix typos in README, pull req #13
+- Fix bug where calling method overloaded sometimes with block and sometimes without would always report type error
 
 ## [1.1.1] - 2016-05-21
 ### Fixed

data/README.md

@@ -148,7 +148,29 @@ For performance reasons you probably don't want to use RDL in production code. T
 
 ## Rails
 
-To use RDL with Rails, use the [rdl-rails](https://github.com/plum-umd/rdl-rails) gem.
+To add types to a Ruby on Rails application, add
+
+```ruby
+gem 'rdl'
+```
+
+to your `Gemfile` to get the latest stable version, or
+
+```ruby
+gem 'rdl', git: 'https://github.com/plum-umd/rdl'
+```
+
+to get the head version from github.
+
+In development and test mode, you will now have access to `rdl`, `types/core` from RDL, and extra type annotations for Rails and some related gems. In production mode, RDL will be disabled (by loading `rdl_disable`).
+
+Currently, rdl has types for the following versions of Rails:
+
+* Rails 5.x support - limited to the following:
+  * Automatically generates
+    * Models
+      * Type annotations for model column getters and setters
+      * `find_by` and `find_by!`
 
 ## Preconditions and Postconditions
 
@@ -688,6 +710,8 @@ RDL uses the same approach for hashes: hash literals are treated as finite hashe
 
 * *Caching.* If `typecheck: :call` is specified on a method, Ruby will type check the method every time it is called. In the future, RDL will cache these checks.
 
+* *Dependent Types.* RDL ignores refinements in checking code with dependent types. E.g., given a `Fixnum x {{ x > 0 }}`, RDL will simply treat `x` as a `Fixnum` and ignore the requirement that it be positive.
+
 * *Unsupported Features.* There are several features of Ruby that are currently not handled by RDL. Here is a non-exhaustive list:
   * `super` is not supported.
   * `lambda` has special semantics for `return`; this is not supported.

data/lib/rdl.rb

@@ -1,129 +1,7 @@
-require 'delegate'
-require 'digest'
-require 'set'
-require 'parser/current'
+# This wrapper file allows us to completely disable RDL in certain modes.
 
-module RDL
+if defined?(Rails)
+  require 'rdl/boot_rails'
+else
+  require 'rdl/boot'
 end
-
-require 'rdl/config.rb'
-def RDL.config
-  yield(RDL::Config.instance)
-end
-require 'rdl/info.rb'
-
-# Method/variable info table with kinds:
-# For methods
-#   :pre to array of precondition contracts
-#   :post to array of postcondition contracts
-#   :type to array of types
-#   :source_location to [filename, linenumber] location of most recent definition
-#   :typecheck - boolean that is true if method should be statically type checked
-#   :otype to set of types that were observed at run time, where a type is a finite hash {:args => Array<Class>, :ret => Class, :block => %bool}
-#   :context_types to array of [klass, meth, Type] - method types that exist only within this method. An icky hack to deal with Rails `params`.
-# For variables
-#   :type to type
-$__rdl_info = RDL::Info.new
-
-# Map from full_method_name to number of times called when wrapped
-$__rdl_wrapped_calls = Hash.new 0
-
-# Hash from class name to array of symbols that are the class's type parameters
-$__rdl_type_params = Hash.new
-
-# Hash from class name to method name to its alias method name
-# class names are strings
-# method names are symbols
-$__rdl_aliases = Hash.new
-
-# Set of [class, method] pairs to wrap.
-# class is a string
-# method is a symbol
-$__rdl_to_wrap = Set.new
-
-# Map from symbols to set of [class, method] pairs to type check when those symbols are rdl_do_typecheck'd
-# (or the methods are defined, for the symbol :now)
-$__rdl_to_typecheck = Hash.new
-$__rdl_to_typecheck[:now] = Set.new
-
-# List of contracts that should be applied to the next method definition
-$__rdl_deferred = []
-
-# Create switches to control whether wrapping happens and whether
-# contracts are checked. These need to be created before rdl/wrap.rb
-# is loaded.
-require 'rdl/switch.rb'
-$__rdl_wrap_switch = RDL::Switch.new
-$__rdl_contract_switch = RDL::Switch.new
-
-require 'rdl/types/type.rb'
-require 'rdl/types/annotated_arg.rb'
-require 'rdl/types/bot.rb'
-require 'rdl/types/dependent_arg.rb'
-require 'rdl/types/dots_query.rb'
-require 'rdl/types/finite_hash.rb'
-require 'rdl/types/generic.rb'
-require 'rdl/types/intersection.rb'
-require 'rdl/types/lexer.rex.rb'
-require	'rdl/types/method.rb'
-require 'rdl/types/singleton.rb'
-require 'rdl/types/nominal.rb'
-require	'rdl/types/non_null.rb'
-require 'rdl/types/optional.rb'
-require 'rdl/types/parser.tab.rb'
-require 'rdl/types/structural.rb'
-require 'rdl/types/top.rb'
-require 'rdl/types/tuple.rb'
-require 'rdl/types/type_query.rb'
-require 'rdl/types/union.rb'
-require 'rdl/types/var.rb'
-require	'rdl/types/vararg.rb'
-require 'rdl/types/wild_query.rb'
-
-require 'rdl/contracts/contract.rb'
-require 'rdl/contracts/and.rb'
-require 'rdl/contracts/flat.rb'
-require 'rdl/contracts/or.rb'
-require 'rdl/contracts/proc.rb'
-
-require 'rdl/util.rb'
-require 'rdl/wrap.rb'
-require 'rdl/query.rb'
-require 'rdl/typecheck.rb'
-#require_relative 'rdl/stats.rb'
-
-$__rdl_parser = RDL::Type::Parser.new
-
-# Map from file names to [digest, cache] where 2nd elt maps
-#  :ast to the AST
-#  :line_defs maps linenumber to AST for def at that line
-$__rdl_ruby_parser_cache = Hash.new
-
-# Some generally useful types; not really a big deal to do this since
-# NominalTypes are cached, but these names are shorter to type
-$__rdl_nil_type = RDL::Type::NominalType.new NilClass # actually creates singleton type
-$__rdl_top_type = RDL::Type::TopType.new
-$__rdl_bot_type = RDL::Type::BotType.new
-$__rdl_object_type = RDL::Type::NominalType.new Object
-$__rdl_true_type = RDL::Type::NominalType.new TrueClass # actually creates singleton type
-$__rdl_false_type = RDL::Type::NominalType.new FalseClass # also singleton type
-$__rdl_bool_type = RDL::Type::UnionType.new($__rdl_true_type, $__rdl_false_type)
-$__rdl_fixnum_type = RDL::Type::NominalType.new Fixnum
-$__rdl_bignum_type = RDL::Type::NominalType.new Bignum
-$__rdl_float_type = RDL::Type::NominalType.new Float
-$__rdl_complex_type = RDL::Type::NominalType.new Complex
-$__rdl_rational_type = RDL::Type::NominalType.new Rational
-$__rdl_integer_type = RDL::Type::UnionType.new($__rdl_fixnum_type, $__rdl_bignum_type)
-$__rdl_numeric_type = RDL::Type::NominalType.new Numeric
-$__rdl_string_type = RDL::Type::NominalType.new String
-$__rdl_array_type = RDL::Type::NominalType.new Array
-$__rdl_hash_type = RDL::Type::NominalType.new Hash
-$__rdl_symbol_type = RDL::Type::NominalType.new Symbol
-$__rdl_range_type = RDL::Type::NominalType.new Range
-$__rdl_regexp_type = RDL::Type::NominalType.new Regexp
-$__rdl_standard_error_type = RDL::Type::NominalType.new StandardError
-
-# Hash from special type names to their values
-$__rdl_special_types = {'%any' => $__rdl_top_type,
-                        '%bot' => $__rdl_bot_type,
-                        '%bool' => $__rdl_bool_type}

data/lib/rdl/boot.rb

@@ -0,0 +1,129 @@
+require 'delegate'
+require 'digest'
+require 'set'
+require 'parser/current'
+
+module RDL
+end
+
+require 'rdl/config.rb'
+def RDL.config
+  yield(RDL::Config.instance)
+end
+require 'rdl/info.rb'
+
+# Method/variable info table with kinds:
+# For methods
+#   :pre to array of precondition contracts
+#   :post to array of postcondition contracts
+#   :type to array of types
+#   :source_location to [filename, linenumber] location of most recent definition
+#   :typecheck - boolean that is true if method should be statically type checked
+#   :otype to set of types that were observed at run time, where a type is a finite hash {:args => Array<Class>, :ret => Class, :block => %bool}
+#   :context_types to array of [klass, meth, Type] - method types that exist only within this method. An icky hack to deal with Rails `params`.
+# For variables
+#   :type to type
+$__rdl_info = RDL::Info.new
+
+# Map from full_method_name to number of times called when wrapped
+$__rdl_wrapped_calls = Hash.new 0
+
+# Hash from class name to array of symbols that are the class's type parameters
+$__rdl_type_params = Hash.new
+
+# Hash from class name to method name to its alias method name
+# class names are strings
+# method names are symbols
+$__rdl_aliases = Hash.new
+
+# Set of [class, method] pairs to wrap.
+# class is a string
+# method is a symbol
+$__rdl_to_wrap = Set.new
+
+# Map from symbols to set of [class, method] pairs to type check when those symbols are rdl_do_typecheck'd
+# (or the methods are defined, for the symbol :now)
+$__rdl_to_typecheck = Hash.new
+$__rdl_to_typecheck[:now] = Set.new
+
+# List of contracts that should be applied to the next method definition
+$__rdl_deferred = []
+
+# Create switches to control whether wrapping happens and whether
+# contracts are checked. These need to be created before rdl/wrap.rb
+# is loaded.
+require 'rdl/switch.rb'
+$__rdl_wrap_switch = RDL::Switch.new
+$__rdl_contract_switch = RDL::Switch.new
+
+require 'rdl/types/type.rb'
+require 'rdl/types/annotated_arg.rb'
+require 'rdl/types/bot.rb'
+require 'rdl/types/dependent_arg.rb'
+require 'rdl/types/dots_query.rb'
+require 'rdl/types/finite_hash.rb'
+require 'rdl/types/generic.rb'
+require 'rdl/types/intersection.rb'
+require 'rdl/types/lexer.rex.rb'
+require	'rdl/types/method.rb'
+require 'rdl/types/singleton.rb'
+require 'rdl/types/nominal.rb'
+require	'rdl/types/non_null.rb'
+require 'rdl/types/optional.rb'
+require 'rdl/types/parser.tab.rb'
+require 'rdl/types/structural.rb'
+require 'rdl/types/top.rb'
+require 'rdl/types/tuple.rb'
+require 'rdl/types/type_query.rb'
+require 'rdl/types/union.rb'
+require 'rdl/types/var.rb'
+require	'rdl/types/vararg.rb'
+require 'rdl/types/wild_query.rb'
+
+require 'rdl/contracts/contract.rb'
+require 'rdl/contracts/and.rb'
+require 'rdl/contracts/flat.rb'
+require 'rdl/contracts/or.rb'
+require 'rdl/contracts/proc.rb'
+
+require 'rdl/util.rb'
+require 'rdl/wrap.rb'
+require 'rdl/query.rb'
+require 'rdl/typecheck.rb'
+#require_relative 'rdl/stats.rb'
+
+$__rdl_parser = RDL::Type::Parser.new
+
+# Map from file names to [digest, cache] where 2nd elt maps
+#  :ast to the AST
+#  :line_defs maps linenumber to AST for def at that line
+$__rdl_ruby_parser_cache = Hash.new
+
+# Some generally useful types; not really a big deal to do this since
+# NominalTypes are cached, but these names are shorter to type
+$__rdl_nil_type = RDL::Type::NominalType.new NilClass # actually creates singleton type
+$__rdl_top_type = RDL::Type::TopType.new
+$__rdl_bot_type = RDL::Type::BotType.new
+$__rdl_object_type = RDL::Type::NominalType.new Object
+$__rdl_true_type = RDL::Type::NominalType.new TrueClass # actually creates singleton type
+$__rdl_false_type = RDL::Type::NominalType.new FalseClass # also singleton type
+$__rdl_bool_type = RDL::Type::UnionType.new($__rdl_true_type, $__rdl_false_type)
+$__rdl_fixnum_type = RDL::Type::NominalType.new Fixnum
+$__rdl_bignum_type = RDL::Type::NominalType.new Bignum
+$__rdl_float_type = RDL::Type::NominalType.new Float
+$__rdl_complex_type = RDL::Type::NominalType.new Complex
+$__rdl_rational_type = RDL::Type::NominalType.new Rational
+$__rdl_integer_type = RDL::Type::UnionType.new($__rdl_fixnum_type, $__rdl_bignum_type)
+$__rdl_numeric_type = RDL::Type::NominalType.new Numeric
+$__rdl_string_type = RDL::Type::NominalType.new String
+$__rdl_array_type = RDL::Type::NominalType.new Array
+$__rdl_hash_type = RDL::Type::NominalType.new Hash
+$__rdl_symbol_type = RDL::Type::NominalType.new Symbol
+$__rdl_range_type = RDL::Type::NominalType.new Range
+$__rdl_regexp_type = RDL::Type::NominalType.new Regexp
+$__rdl_standard_error_type = RDL::Type::NominalType.new StandardError
+
+# Hash from special type names to their values
+$__rdl_special_types = {'%any' => $__rdl_top_type,
+                        '%bot' => $__rdl_bot_type,
+                        '%bool' => $__rdl_bool_type}

data/lib/rdl/boot_rails.rb

@@ -0,0 +1,13 @@
+if Rails.env.development? || Rails.env.test?
+  require 'rdl/boot'
+  require 'types/core'
+
+  dir = Rails::VERSION::STRING.split('.')[0] + ".x"
+  require_relative "../types/rails-#{dir}/_helpers.rb" # load type aliases first
+  Dir[File.dirname(__FILE__) + "/../types/rails-#{dir}/**/*.rb"].each { |f| require f }
+elsif Rails.env.production?
+  require 'rdl_disable'
+  def (ActionController::Base).params_type(typs); end
+else
+  raise RuntimeError, "Don't know what to do in Rails environment #{Rails.env}"
+end

data/lib/rdl/typecheck.rb

@@ -805,9 +805,6 @@ RUBY
     when :lvar  # local variable
       error :undefined_local_or_method, [name], e unless env.has_key? name
       capture(scope, name, env[name].canonical) if scope[:outer_env] && (scope[:outer_env].has_key? name) && (not (scope[:outer_env].fixed? name))
-      # if scope[:outer_env] && (scope[:outer_env].has_key? name) && (not (scope[:outer_env].fixed? name))
-      #   error :nonlocal_access, [name], e
-      # end
       if scope[:captured] && scope[:captured].has_key?(name) then
         [env, scope[:captured][name]]
       else
@@ -1114,6 +1111,7 @@ RUBY
   # *always* included module's instance methods only
   # if included, those methods are added to instance_methods
   # if extended, those methods are added to singleton_methods
+  # (except Kernel is special...)
   def self.lookup(scope, klass, name, e)
     if scope[:context_types]
       # return array of all matching types from context_types, if any
@@ -1121,7 +1119,11 @@ RUBY
       scope[:context_types].each { |ctk, ctm, ctt| ts << ctt if ctk.to_s == klass && ctm == name  }
       return ts unless ts.empty?
     end
-    return scope[:context_types][klass][name] if scope[:context_types] && scope[:context_types][klass] && scope[:context_types][klass][name]
+    if scope[:context_types]
+      scope[:context_types].each { |k, m, t|
+        return t if k == klass && m = name
+      }
+    end
     t = $__rdl_info.get_with_aliases(klass, name, :type)
     return t if t # simplest case, no need to walk inheritance hierarchy
     the_klass = RDL::Util.to_class(klass)
@@ -1141,7 +1143,10 @@ RUBY
         return tancestor if tancestor
       end
       if ancestor.instance_methods(false).member?(name)
-        klass = RDL::Util.remove_singleton_marker klass if RDL::Util.has_singleton_marker klass
+        if RDL::Util.has_singleton_marker klass
+          klass = RDL::Util.remove_singleton_marker klass
+          klass = '(singleton) ' + klass
+        end
         error :missing_ancestor_type, [ancestor, klass, name], e
       end
     }
@@ -1162,18 +1167,17 @@ type_error_messages = {
   inconsistent_var_type: "local variable `%s' has declared type on some paths but not all",
   inconsistent_var_type_type: "local variable `%s' declared with inconsistent types %s",
   no_each_type: "can't find `each' method with signature `() { (t1) -> t2 } -> t3' in class `%s'",
-  tuple_finite_hash_promote: "can't promote %s to %s",
+  tuple_finite_hash_promote: "can't promote `%s' to `%s'",
   masgn_bad_rhs: "multiple assignment has right-hand side of type `%s' where tuple or array expected",
   masgn_num: "can't multiple-assign %d values to %d variables",
   masgn_bad_lhs: "no corresponding right-hand side elemnt for left-hand side assignee",
-  kw_not_allowed: "can't use %s in current scope",
-  kw_arg_not_allowed: "argument to %s not allowed in current scope",
-  arg_count_mismatch: "%s signature expects %d arguments, actual %s has %d arguments",
-  nonlocal_access: "variable %s from outer scope must have type declared with var_type",
+  kw_not_allowed: "can't use `%s' in current scope",
+  kw_arg_not_allowed: "argument to `%s' not allowed in current scope",
+  arg_count_mismatch: "`%s' signature expects %d arguments, actual `%s' has %d arguments",
   no_block: "attempt to call yield in method not declared to take a block argument",
   block_block: "can't call yield on a block expecting another block argument",
   block_type_error: "argument type error for block\n%s",
-  missing_ancestor_type: "ancestor %s of %s has method %s but no type for it",
+  missing_ancestor_type: "ancestor `%s' of `%s' has method `%s' but no type for it",
   type_cast_format: "type_cast must be called as `type_cast type-string' or `type_cast type-string, force: expr'",
   var_type_format: "var_type must be called as `var_type :var-name, type-string'",
   puts_type_format: "puts_type must be called as `puts_type e'",

data/lib/rdl/types/method.rb

@@ -61,10 +61,10 @@ module RDL::Type
 	        check_arg_preds(bind, preds) if preds.size > 0
           @args.each_with_index {|a,i| args[i] = block_wrap(slf, inst, a, bind, &args[i]) if a.is_a? MethodType }
           if @block then
-            raise TypeError, "Expected method block of type {@block}, received no block." unless blk
+            next unless blk
             blk = block_wrap(slf, inst, @block, bind, &blk)
           elsif blk then
-            raise TypeError, "Block passed to method expecting no block."
+            next
           end
           return [true, args, blk, bind]
         end

data/lib/rdl/wrap.rb

@@ -537,6 +537,7 @@ class Object
 
   # Type check all methods that had annotation `typecheck: sym' at type call
   def rdl_do_typecheck(sym)
+    return unless $__rdl_to_typecheck[sym]
     $__rdl_to_typecheck[sym].each { |klass, meth|
       RDL::Typecheck.typecheck(klass, meth)
     }

data/lib/rdl_disable.rb

@@ -18,6 +18,7 @@ class Object
   def type_alias(*args); end
   def rdl_do_typecheck(*args); end
   def rdl_note_type(*args); end
+  def rdl_remove_type(*args); end
 
   def attr_accessor_type(*args)
     args.each_slice(2) { |name, typ| attr_accessor name }
@@ -35,7 +36,4 @@ class Object
     args.each_slice(2) { |name, typ| attr_writer name }
     nil
   end
-
-
-
 end

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

@@ -0,0 +1,32 @@
+# :integer, :bigint, :float, :decimal, :numeric, :datetime, :time, :date, :binary, :boolean.
+# null allowed
+
+module RDL
+  class Rails
+
+    # [+ rails_type +] is a Rails column type (:string, :integer, etc)
+    # returns a String containing an RDL type
+    def self.column_to_rdl(rails_type)
+      case rails_type
+      when :string, :text, :binary
+        return 'String'
+      when :integer
+        return 'Fixnum'
+      when :float
+        return 'Float'
+      when :decimal
+        return 'BigDecimal'
+      when :boolean
+        return '%bool'
+      when :date
+        return 'Date'
+      when :time
+        return 'Time'
+      when :datetime
+        return 'DateTime'
+      else
+        raise RuntimeError, "Unrecoganized column type #{rails_type}"
+      end
+    end
+  end
+end

data/lib/types/rails-5.x/action_controller/mime_responds.rb

@@ -0,0 +1,11 @@
+module ActionController
+  module MimeResponds
+    type :respond_to, '(*(String or Symbol)) { (ActionController::MimeResponds::Collector) -> %any } -> Array<String> or String'
+
+    class Collector
+      Mime::EXTENSION_LOOKUP.each { |mime|
+        type :method_missing, "(#{mime[1].symbol.inspect}) { (ActionController::MimeResponds::Collector::VariantCollector) -> %any } -> %any"
+      }
+    end
+  end
+end

data/lib/types/rails-5.x/action_controller/strong_parameters.rb

@@ -0,0 +1,22 @@
+# TODO: This is all a bit of a hack. Right now, ActionControll::Parameters has its [] method set appropriately during the context
+# of the next method by params_types. But that doesn't quite match what actually happens in Rails.
+
+class ActionController::Base
+
+  # [+ typ_hash +] is a Hash<Symbol, String>, where the keys are the parameter names and the Strings are the corresponding types
+  # adds these parameters to the `params` hash in the immediately following controller method
+  def self.params_type(typs)
+    # TODO: Ick, this is ugly. Once it's obvious how to generalize this kind of reasoning to other cases, clean this up!
+    typs.each_pair { |param, param_type|
+      param_type = $__rdl_parser.scan_str "#T #{param_type}"
+      meth_type = $__rdl_parser.scan_str "(#{param.inspect}) -> #{param_type}" # given singleton symbol arg, get param's return type
+      $__rdl_deferred << [self, :context_types, [ActionController::Parameters, :[], meth_type], class_check: self]
+    }
+  end
+end
+
+module ActionController
+  module StrongParameters
+    type :params, '() -> ActionController::Parameters'
+  end
+end

data/lib/types/rails-5.x/action_dispatch/routing.rb

@@ -0,0 +1,10 @@
+module ActionDispatch
+  module Routing
+    class RouteSet
+      post(:draw) { |ret|
+#        puts "Routes are: #{Rails.application.routes.named_routes.helper_names}"
+        true
+      }
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+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
+            # may be null; show nullability in return type
+            type name,       "() -> #{t} or nil"     # getter
+            type "#{name}=", "(#{t}) -> #{t} or nil" # setter
+            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
+            type "#{name}=", "(!#{t}) -> !#{t}" # setter
+            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'
+
+        # If called with String arguments, can't check types as precisely
+        type 'write_attribute', '(String, %any) -> %bool'
+        type 'update_attribute', '(String, %any) -> %bool'
+        type 'update_column', '(String, %any) -> %bool'
+        true
+      }
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+class Fixnum
+  type :*, '(ActiveSupport::Duration) -> ActiveSupport::Duration'
+end

data/rdl.gemspec

@@ -4,8 +4,8 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '2.0.0.rc3'
-  s.date        = '2016-08-11'
+  s.version     = '2.0.0.rc4'
+  s.date        = '2016-08-13'
   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

@@ -1,7 +1,7 @@
 require 'minitest/autorun'
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
-require 'rdl_types'
+require 'types/core'
 
 class TestLe < Minitest::Test
   include RDL::Type

data/test/test_lib_types.rb

@@ -10,7 +10,7 @@ require 'uri'
 require 'minitest/autorun'
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
-require 'rdl_types.rb'
+require 'types/core'
 
 class Dummy
   def self.each

data/test/test_type_contract.rb

@@ -264,4 +264,31 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p8.call(43, x: "foo", y: "foo") }
     assert_raises(TypeError) { p8.call(43, x: :foo, y: "foo", z: 44) }
   end
+
+  type '() { () -> nil } -> nil'
+  def _test_with_block
+    nil
+  end
+
+  type '() -> nil'
+  def _test_without_block
+    nil
+  end
+
+  type '() -> nil'
+  type '() { () -> nil } -> nil'
+  def _test_with_without_block
+    nil
+  end
+
+  def test_block
+    assert_nil(_test_with_block { nil })
+    assert_raises(TypeError) { _test_with_block }
+
+    assert_raises(TypeError) { _test_without_block { nil } }
+    assert_nil(_test_without_block)
+
+    assert_nil(_test_with_without_block)
+    assert_nil(_test_with_without_block { nil })
+  end
 end

data/test/test_typecheck.rb

@@ -1,7 +1,7 @@
 require 'minitest/autorun'
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
-require 'rdl_types'
+require 'types/core'
 
 class TestTypecheck < Minitest::Test
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdl
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc3
+  version: 2.0.0.rc4
 platform: ruby
 authors:
 - Jeffrey S. Foster
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-11 00:00:00.000000000 Z
+date: 2016-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -112,6 +112,8 @@ files:
 - extras/type_tests/|.rb
 - gemfiles/Gemfile.travis
 - lib/rdl.rb
+- lib/rdl/boot.rb
+- lib/rdl/boot_rails.rb
 - lib/rdl/config.rb
 - lib/rdl/contracts/and.rb
 - lib/rdl/contracts/contract.rb
@@ -151,7 +153,6 @@ files:
 - lib/rdl/util.rb
 - lib/rdl/wrap.rb
 - lib/rdl_disable.rb
-- lib/rdl_types.rb
 - lib/types/core-ruby-2.x/_aliases.rb
 - lib/types/core-ruby-2.x/abbrev.rb
 - lib/types/core-ruby-2.x/array.rb
@@ -201,6 +202,12 @@ files:
 - lib/types/core-ruby-2.x/uri.rb
 - lib/types/core-ruby-2.x/yaml.rb
 - lib/types/core.rb
+- lib/types/rails-5.x/_helpers.rb
+- lib/types/rails-5.x/action_controller/mime_responds.rb
+- lib/types/rails-5.x/action_controller/strong_parameters.rb
+- lib/types/rails-5.x/action_dispatch/routing.rb
+- lib/types/rails-5.x/active_record/model_schema.rb
+- lib/types/rails-5.x/fixnum.rb
 - rdl.gemspec
 - test/disabled_test_coverage.rb
 - test/disabled_test_rdoc.rb

data/lib/rdl_types.rb

@@ -1 +0,0 @@
-require_relative "types/core.rb"