rdl 2.0.1 → 2.1.0

data/lib/types/core/strscan.rb

@@ -0,0 +1,6 @@
+RDL.nowrap :StringScanner
+
+RDL.type :StringScanner, 'self.new', '(String, ?%bool) -> StringScanner'
+RDL.type :StringScanner, :eos?, '() -> %bool'
+RDL.type :StringScanner, :scan, '(Regexp) -> String'
+RDL.type :StringScanner, :getch, '() -> String'

data/lib/types/core/symbol.rb

@@ -0,0 +1,27 @@
+RDL.nowrap :Symbol
+
+RDL.type :Symbol, 'self.all_symbols', '() -> Array<Symbol>'
+RDL.type :Symbol, :<=>, '(Symbol other) -> Integer or nil'
+RDL.type :Symbol, :==, '(%any obj) -> %bool'
+RDL.type :Symbol, :=~, '(%any obj) -> Integer or nil'
+RDL.type :Symbol, :[], '(Integer idx) -> String'
+RDL.type :Symbol, :[], '(Integer b, Integer n) -> String'
+RDL.type :Symbol, :[], '(Range<Integer>) -> String'
+RDL.type :Symbol, :capitalize, '() -> Symbol'
+RDL.type :Symbol, :casecmp, '(Symbol other) -> Integer or nil'
+RDL.type :Symbol, :downcase, '() -> Symbol'
+RDL.type :Symbol, :empty?, '() -> %bool'
+RDL.type :Symbol, :encoding, '() -> Encoding'
+RDL.type :Symbol, :id2name, '() -> String'
+RDL.type :Symbol, :inspect, '() -> String'
+RDL.type :Symbol, :intern, '() -> self'
+RDL.type :Symbol, :length, '() -> Integer'
+RDL.type :Symbol, :match, '(%any obj) -> Integer or nil'
+RDL.type :Symbol, :succ, '() -> Symbol'
+RDL.rdl_alias :Symbol, :size, :length
+RDL.rdl_alias :Symbol, :slice, :[]
+RDL.type :Symbol, :swapcase, '() -> Symbol'
+RDL.type :Symbol, :to_proc, '() -> Proc' # TODO proc
+RDL.rdl_alias :Symbol, :to_s, :id2name
+RDL.rdl_alias :Symbol, :to_sym, :intern
+RDL.type :Symbol, :upcase, '() -> Symbol'

data/lib/types/core/time.rb

@@ -0,0 +1,66 @@
+RDL.nowrap :Time
+
+RDL.type :Time, 'self.at', '(Time) -> Time'
+RDL.type :Time, 'self.at', '(Numeric seconds_with_frac) -> Time'
+RDL.type :Time, 'self.at', '(Numeric seconds, Numeric microseconds_with_frac) -> Time'
+RDL.type :Time, 'self.gm', '(Integer year, ?(Integer or String) month, ?Integer day, ?Integer hour, ?Integer min, ?Numeric sec, ?Numeric usec_with_frac) -> Time'
+RDL.type :Time, 'self.local', '(Integer year, ?(Integer or String) month, ?Integer day, ?Integer hour, ?Integer min, ?Numeric sec, ?Numeric usec_with_frac) -> Time'
+RDL.rdl_alias :Time, 'self.mktime', 'self.local'
+RDL.type :Time, :initialize, '(?Integer year, ?(Integer or String) month, ?Integer day, ?Integer hour, ?Integer min, ?Numeric sec, ?Numeric usec_with_frac) -> self'
+RDL.type :Time, 'self.now', '() -> Time'
+RDL.type :Time, 'self.utc', '(Integer year, ?(Integer or String) month, ?Integer day, ?Integer hour, ?Integer min, ?Numeric sec, ?Numeric usec_with_frac) -> Time'
+
+RDL.type :Time, :+, '(Numeric) -> Time'
+RDL.type :Time, :-, '(Time) -> Float'
+RDL.type :Time, :-, '(Numeric) -> Time'
+RDL.type :Time, :<=>, '(Time other) -> -1 or 0 or 1 or nil'
+RDL.type :Time, :asctime, '() -> String'
+RDL.type :Time, :ctime, '() -> String'
+RDL.type :Time, :day, '() -> Integer'
+RDL.type :Time, :dst?, '() -> %bool'
+RDL.type :Time, :eql?, '(%any) -> %bool'
+RDL.type :Time, :friday?, '() -> %bool'
+RDL.type :Time, :getgm, '() -> Time'
+RDL.type :Time, :getlocal, '(?Integer utc_offset) -> Time'
+RDL.type :Time, :getutc, '() -> Time'
+RDL.type :Time, :gmt?, '() -> %bool'
+RDL.type :Time, :gmt_offset, '() -> Integer'
+RDL.type :Time, :gmtime, '() -> self'
+RDL.rdl_alias :Time, :gmtoff, :gmt_offset
+RDL.type :Time, :hash, '() -> Integer'
+RDL.type :Time, :hour, '() -> Integer'
+RDL.type :Time, :inspect, '() -> String'
+RDL.type :Time, :isdst, '() -> %bool'
+RDL.type :Time, :localtime, '(?String utc_offset) -> self'
+RDL.type :Time, :mday, '() -> Integer'
+RDL.type :Time, :min, '() -> Integer'
+RDL.type :Time, :mon, '() -> Integer'
+RDL.type :Time, :monday?, '() -> %bool'
+RDL.rdl_alias :Time, :month, :mon
+RDL.type :Time, :nsec, '() -> Integer'
+RDL.type :Time, :round, '(Integer) -> Time'
+RDL.type :Time, :saturday, '() -> %bool'
+RDL.type :Time, :sec, '() -> Integer'
+RDL.type :Time, :strftime, '(String) -> String'
+RDL.type :Time, :subsec, '() -> Numeric'
+RDL.type :Time, :succ, '() -> Time'
+RDL.type :Time, :sunday?, '() -> %bool'
+RDL.type :Time, :thursday?, '() -> %bool'
+RDL.type :Time, :to_a, '() -> [Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, %bool, String]'
+RDL.type :Time, :to_f, '() -> Float'
+RDL.type :Time, :to_i, '() -> Numeric'
+RDL.type :Time, :to_r, '() -> Rational'
+RDL.type :Time, :to_s, '() -> String'
+RDL.type :Time, :tuesday?, '() -> %bool'
+RDL.type :Time, :tv_nsec, '() -> Numeric'
+RDL.type :Time, :tv_sec, '() -> Numeric'
+RDL.type :Time, :tv_usec, '() -> Numeric'
+RDL.type :Time, :usec, '() -> Numeric'
+RDL.type :Time, :utc, '() -> self'
+RDL.type :Time, :utc?, '() -> %bool'
+RDL.type :Time, :utc_offset, '() -> Integer'
+RDL.type :Time, :wday, '() -> Integer'
+RDL.type :Time, :wednesday?, '() -> %bool'
+RDL.type :Time, :yday, '() -> Integer'
+RDL.type :Time, :year, '() -> Integer'
+RDL.type :Time, :zone, '() -> String'

data/lib/types/core/uri.rb

@@ -0,0 +1,18 @@
+RDL.nowrap :URI
+
+RDL.type :URI, :decode_www_form, '(String, ?Encoding, ?String separator, %bool use_charset, %bool isindex) -> Array<[String,String]>'
+RDL.type :URI, :decode_www_form_component, '(String, ?Encoding) -> Array<[String,String]>'
+# RDL.type :URI, :encode_www_form, '(Array<Array<String>>, ?) -> String' #Doublesplat
+# RDL.type :URI, :encode_www_form_component, '(String, ?) -> String'
+RDL.type :URI, :extract, '(String, ?Array) { (*%any) -> %any} -> Array<String>'
+RDL.type :URI, :join, '(*String) -> URI::HTTP'
+RDL.type :URI, :parse, '(String) -> URI::HTTP'
+RDL.type :URI, :regexp, '(?Array schemes) -> Array<String>' #Assume schemes are strings
+RDL.type :URI, :scheme_list, '() -> Hash<String,Class>'
+RDL.type :URI, :split, '(String) -> Array<String or nil>'
+
+RDL.type :URI, :escape, '(String, *Regexp) -> String'
+RDL.type :URI, :escape, '(String, *String) -> String'
+RDL.type :URI, :unescape, '(*String) -> String'
+RDL.rdl_alias :URI, :encode, :escape
+RDL.rdl_alias :URI, :decode, :unescape

data/lib/types/core/yaml.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :YAML
+
+RDL.type :YAML, 'self.load_file', '(String) -> Array<String>'

data/lib/types/devise.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/devise/**/*.rb"].each { |f| require f }

data/lib/types/devise/controller_helpers.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :'Devise::Controllers::Helpers'
+RDL.type :'Devise::Controllers::Helpers', :devise_parameter_sanitizer, '() -> Devise::ParameterSanitizer'
+RDL.type :'Devise::Controllers::Helpers', :current_user, '() -> User'

data/lib/types/devise/parameter_sanitizer.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'Devise::ParameterSanitizer'
+RDL.type :'Devise::ParameterSanitizer', :permit, '(Symbol, Hash<Symbol, Array<Symbol>>) -> NilClass'

data/lib/types/pundit.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :Pundit
+RDL.type :Pundit, :authorize, '(%any, ?%any) -> %any'

data/lib/types/rails/_helpers.rb

@@ -0,0 +1,50 @@
+# :integer, :bigint, :float, :decimal, :numeric, :datetime, :time, :date, :binary, :boolean.
+# null allowed
+
+RDL.type_alias '%symstr', 'Symbol or String'
+
+class RDL::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
+
+  # [+ 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

data/lib/types/rails/abstract_controller/translation.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'AbstractController::Translation'
+RDL.type :'AbstractController::Translation', :t, '(Symbol or String) -> String'

data/lib/types/rails/action_controller/base.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :'ActionController::Base'
+RDL.type :'ActionController::Base', 'self.helpers', '() -> ActionView::Base'
+RDL.type :'ActionController::Base', :logger, '() -> ActiveSupport::TaggedLogging'

data/lib/types/rails/action_controller/instrumentation.rb

@@ -0,0 +1,6 @@
+RDL.nowrap :'ActionController::Instrumentation'
+RDL.type :'ActionController::Instrumentation', :render, '(String or Symbol) -> Array<String>'
+RDL.type :'ActionController::Instrumentation', :render, '(?String or Symbol, {content_type: ?String, layout: ?%bool or String, action: ?String or Symbol, location: ?String, nothing: ?%bool, text: ?[to_s: () -> String], status: ?Symbol, content_type: ?String, formats: ?Symbol or Array<Symbol>, locals: ?Hash<Symbol, %any>}) -> Array<String>'
+RDL.type :'ActionController::Instrumentation', :redirect_to, '(:back) -> String'
+RDL.type :'ActionController::Instrumentation', :redirect_to, '({controller: ?String, action: ?String, notice: ?String, alert: ?String}) -> String'
+RDL.type :'ActionController::Instrumentation', :redirect_to, '(String or Symbol or ActiveRecord::Base, ?{controller: ?String, action: ?String, notice: ?String, alert: ?String}) -> String'

data/lib/types/rails/action_controller/metal.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :'ActionController::Metal'
+RDL.type :'ActionController::Metal', :params, '() -> ActiveSupport::HashWithIndifferentAccess<String or Symbol, v>'
+RDL.type :'ActionController::Metal', :request, '() -> ActionDispatch::Request'

data/lib/types/rails/action_controller/mime_responds.rb

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

data/lib/types/rails/action_controller/parameters.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :'ActionController::Parameters'
+RDL.type :'ActionController::Parameters', :require, '(*Symbol) -> ActionController::Parameters'
+RDL.type :'ActionController::Parameters', :permit, '(*Symbol) -> ActionController::Parameters'

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

@@ -8,15 +8,11 @@ class ActionController::Base
   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]
+      param_type = RDL::Globals.parser.scan_str "#T #{param_type}"
+      meth_type = RDL::Globals.parser.scan_str "(#{param.inspect}) -> #{param_type}" # given singleton symbol arg, get param's return type
+      RDL::Globals.deferred << [self, :context_types, [ActionController::Parameters, :[], meth_type], class_check: self]
     }
   end
 end
 
-module ActionController
-  module StrongParameters
-    type :params, '() -> ActionController::Parameters'
-  end
-end
+RDL.type :'ActionController::StrongParameters', :params, '() -> ActionController::Parameters'

data/lib/types/rails/action_dispatch/flashhash.rb

@@ -0,0 +1,8 @@
+RDL.nowrap :'ActionDispatch::Flash::FlashHash'
+RDL.type :'ActionDispatch::Flash::FlashHash', :[], '(Symbol) -> String'
+RDL.type :'ActionDispatch::Flash::FlashHash', :[]=, '(Symbol, String) -> String'
+RDL.type :'ActionDispatch::Flash::FlashHash', :now, '() -> ActionDispatch::Flash::FlashNow'
+
+RDL.nowrap :'ActionDispatch::Flash::FlashNow'
+RDL.type :'ActionDispatch::Flash::FlashNow', :[], '(Symbol) -> String'
+RDL.type :'ActionDispatch::Flash::FlashNow', :[]=, '(Symbol, String) -> String'

data/lib/types/rails/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/action_mailer/base.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActionMailer::Base'
+RDL.type :'ActionMailer::Base', :mail, '({subject: ?String, to: ?String, from: ?String, cc: ?String or Array<String>, bcc: ?String or Array<String>, reply_to: ?String, date: ?String}) -> Mail::Message'

data/lib/types/rails/action_mailer/message_delivery.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActionMailer::MessageDelivery'
+RDL.type :'ActionMailer::MessageDelivery', :deliver_now, '() -> Mail::Message'

data/lib/types/rails/action_view/helpers_sanitizehelper.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActionView::Helpers::SanitizeHelper'
+RDL.type :'ActionView::Helpers::SanitizeHelper', :strip_tags, '(String) -> String'

data/lib/types/rails/action_view/helpers_urlhelper.rb

@@ -0,0 +1,5 @@
+RDL.nowrap :'ActionView::Helpers::UrlHelper'
+RDL.type :'ActionView::Helpers::UrlHelper', :link_to, '(String, String or ActiveRecord::Base, ?Hash<Symbol, %any>) -> ActiveSupport::SafeBuffer'
+RDL.type :'ActionView::Helpers::UrlHelper', :link_to, '(String, ?Hash<Symbol, %any>, ?Hash<Symbol, %any>) -> ActiveSupport::SafeBuffer'
+RDL.type :'ActionView::Helpers::UrlHelper', :link_to, '(?Hash<Symbol, %any>, ?Hash<Symbol, %any>) {() -> String} -> ActiveSupport::SafeBuffer'
+RDL.type :'ActionView::Helpers::UrlHelper', :link_to, '(?String, ?Hash<Symbol, %any>) {() -> String} -> ActiveSupport::SafeBuffer'

data/lib/types/rails/active_model/errors.rb

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

data/lib/types/rails/active_model/validations.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveModel::Validations'
+RDL.type :'ActiveModel::Validations', :errors, '() -> ActiveModel::Errors'

data/lib/types/rails/active_record/associations.rb

@@ -0,0 +1,208 @@
+RDL.nowrap :'ActiveRecord::Associations::CollectionProxy'
+
+RDL.type_params :'ActiveRecord::Associations::CollectionProxy', [:t], :all?
+
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :<<, '(*(t or Array<t>)) -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :==, '(%any) -> %bool'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :any?, '() ?{ (t) -> %bool } -> %bool'
+RDL.rdl_alias :'ActiveRecord::Associations::CollectionProxy', :append, :<<
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :build, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :clear, '() -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :concat, '(*t) -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :count, '() -> Integer'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :create, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :create!, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :delete, '(*t) -> Array<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :delete_all, '(?Symbol dependent) -> Array<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :destroy, '(*t) -> Array<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :destroy_all, '() -> %any'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :distinct, '() -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :empty?, '() -> %bool'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :find, '(Integer) -> t'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :find, '(Integer, Integer, *Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :include?, '(t) -> %bool'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :length, '() -> Integer'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :load_target, '() -> %any'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :loaded?, '() -> %bool'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :many?, '() ?{ (t) -> %bool } -> %bool'
+RDL.rdl_alias :'ActiveRecord::Associations::CollectionProxy', :new, :build
+RDL.rdl_alias :'ActiveRecord::Associations::CollectionProxy', :push, :<<
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :reload, '() -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :replace, '(Array<t>) -> %any'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :reset, '() -> self'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :scope, '() -> ActiveRecord::Relation' # TODO fix
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :select, '(*Symbol) -> t'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :select, '() { (t) -> %bool } -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :size, '() -> Integer'
+RDL.rdl_alias :'ActiveRecord::Associations::CollectionProxy', :spawn, :scope
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :take, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :take, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :to_ary, '() -> Array<t>'
+RDL.rdl_alias :'ActiveRecord::Associations::CollectionProxy', :to_a, :to_ary
+RDL.rdl_alias :'ActiveRecord::Associations::CollectionProxy', :unique, :distinct
+
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :first, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :first, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :second, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :second, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :third, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :third, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :fourth, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :fourth, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :fifth, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :fifth, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :forty_two, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :forty_two, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :third_to_last, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :third_to_last, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :second_to_last, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :second_to_last, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :last, '() -> t or nil'
+RDL.type :'ActiveRecord::Associations::CollectionProxy', :last, '(Integer) -> ActiveRecord::Associations::CollectionProxy<t>'
+
+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
+
+  extend RDL::RDLAnnotate
+
+  rdl_type :'ActiveRecord::Associations::ClassMethods', :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'
+
+  rdl_pre :'ActiveRecord::Associations::ClassMethods', :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
+    rdl_type name, "(?%bool force_reload) -> #{assoc_type}"
+    rdl_type "#{name}=", "(#{assoc_type}) -> #{assoc_type}"
+    unless polymorphic
+      RDL.at(:model) { |sym|
+        assoc_attribute_types = RDL::Rails.attribute_types(assoc_type.constantize)
+        rdl_type "build_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+        rdl_type "create_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+        rdl_type "create_#{name}!", "(#{assoc_attribute_types}) -> #{assoc_type}"
+      }
+    end
+    true
+  end
+
+  rdl_type :'ActiveRecord::Associations::ClassMethods', :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'
+
+  rdl_pre :'ActiveRecord::Associations::ClassMethods', :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
+    rdl_type name, "(?%bool force_reload) -> #{assoc_type}"
+    rdl_type "#{name}=", "(#{assoc_type}) -> #{assoc_type}"
+    unless as
+      RDL.at(:model) { |sym|
+       assoc_attribute_types = RDL::Rails.attribute_types(assoc_type.constantize)
+       rdl_type "build_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+       rdl_type "create_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
+       rdl_type "create_#{name}!", "(#{assoc_attribute_types}) -> #{assoc_type}"
+     }
+    end
+  end
+
+  rdl_type :'ActiveRecord::Associations::ClassMethods', :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'
+
+  rdl_pre :'ActiveRecord::Associations::ClassMethods', :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
+    rdl_type name, "() -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>"
+    rdl_type "#{name}=", "(Array<t>) -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>" # TODO not sure of type
+    RDL.at(:model) {
+      # primary_key is not available when has_many is first called!
+      id_type = RDL::Rails.column_to_rdl(collect_type.constantize.columns_hash[primary_key].type)
+      rdl_type "#{name.to_s.singularize}_ids", "() -> Array<#{id_type}>"
+      rdl_type "#{name.to_s.singularize}_ids=", "() -> Array<#{id_type}>"
+    }
+    true
+  end
+
+  rdl_type :'ActiveRecord::Associations::ClassMethods', :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'
+
+  rdl_pre :'ActiveRecord::Associations::ClassMethods', :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
+    rdl_type name, "() -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>"
+    rdl_type "#{name}=", "(Array<t>) -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>" # TODO not sure of type
+    RDL.at(:model) {
+      # primary_key is not available when has_and_belongs_to_many is first called!
+      id_type = RDL::Rails.column_to_rdl(collect_type.constantize.columns_hash[primary_key].type)
+      rdl_type "#{name.to_s.singularize}_ids", "() -> Array<#{id_type}>"
+      rdl_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