sorbet-rails 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f46a2ecda33e62dbb1410943780827a098f5019d
-  data.tar.gz: fe0478758bf1882d6ef2749d9b1cdf56a96afebd
+  metadata.gz: 6a4e4c9b0f6d3cb813771d9673fb2c483507292f
+  data.tar.gz: d34bda0c4a4a9269b8bf6a32cd8e7734888613d3
 SHA512:
-  metadata.gz: 6a194e4ea66176b304fae0b7bffa5ab1b301ba02d1cc2c9d6697538e45082d1ff0a52a57cc2e9f666764bcbf30a0e62c8498ec4b7c5a6952fb91d7cab506ea09
-  data.tar.gz: 3a2727165b5963f0b9ea9f067053330e00fe829ab5ab3f9ac098319c74e149565d8cf244f297d3aab1706f5a2fc5882a8a1978d88d6b01a7dd1b92ffe7166031
+  metadata.gz: 8a346f014c1761602c445cc5ce1241e9643988433776c7d05f250f0a85d355bf5226a15b160ed1bf843b1d2268069ed736e16687a9a013e0494a3000aae20eb5
+  data.tar.gz: 7844cc11287fe4108610435b9b8cba3387d122c0a074b92c89d22ad058ffcbc0c17cca311c9e38c38314ec049c30c25933359183d5b3f7cfbfe7de8a3c5e0f6e

data/.codecov.yml

@@ -0,0 +1,4 @@
+fixes:
+ # Ensure Codecov can follow files within symlinked directories
+ - "spec/support/v*/app/controllers::spec/support/rails_shared/app/controllers"
+ - "spec/support/v*/app/models::spec/support/rails_shared/app/models"

data/.github/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,26 @@
+---
+name: Report a bug
+about: Create a report to help us improve
+labels: bug
+---
+
+**Describe the bug:**
+
+
+**Steps to reproduce:**
+
+
+**Expected behavior:**
+
+
+**Versions:**
+<!-- Please include what software versions you are running.
+     You can get many of these by running CLI commands, such as:
+     $ ruby --version
+     $ rails --version
+     $ srb --version
+-->
+- Ruby:
+- Rails:
+- Sorbet:
+- Sorbet-Rails:

data/.gitignore

@@ -76,3 +76,8 @@ Gemfile.lock
 # Ignore master key for decrypting credentials and more.
 /spec/support/**/config/master.key
 
+# Ignore sorbet-rails generated files
+/spec/support/**/sorbet/rails-rbi/*
+/spec/support/**/sorbet/rails-rbi/**/*
+
+

data/.travis.yml

@@ -1,19 +1,38 @@
 language: ruby
 env:
-  - "RAILS_VERSION=5.1.7"
-  - "RAILS_VERSION=5.2.3"
+  matrix:
+  - RAILS_VERSION=4.2
+  - RAILS_VERSION=5.0
+  - RAILS_VERSION=5.1
+  - RAILS_VERSION=5.2
+  - RAILS_VERSION=6.0
+  global:
+    secure: S3rpBSDgDQjhA11/80dZ4RUlBP3XLJWOgvcl1eySFdXqHCZGS5p8Fa97yEvZHWiPInUTNhdvyQ5LHlgzu1CCZ9+MOykpEgYo+1yIueriv9Ia5PUNFbwhRp2eBkluSUMPNPOxf15mUlgAGdScnssRL9zftYel29dw4yg+BQnnkLOqpnLO7wHTjouEmp7M8Y/1j0ScIZ0tZL1ovDq70Lst+TJKHm4jdBbwoNmILIwNBgnzZT1LdAuaXVHEmwLvy0GLvClewuSmToJ4jyjuJorCjyMhyoBLrutSuN4KaJcSlP/LVtH4ZCFkFDayDMiVcSyUE3asSnL3yxGL0K99lgwNk4D58WWic7N+0UKnGoiMQOHC9EIsQKaxfXMOpO+Cq5wYhgmFzPGF4iL6ZBNCehcc+ToBojprmJw/0Ev71OS2YGvu5SZpYco5AvJeR73IUA2K0rjUEeY3gXm60aIac09kQuuminN3hUkJ894YoA35B8IEU0uW2uL5n/vX2Y8SD6RV8csbKlhpJmphYYWQQOYjHuFoW4MVnnrFHq6YIUDQpi6/We3I4xH3kvfjIpSemrYOmfF4PPXCarWA7ryI9ytR7BloQ0NQH7hqp1hbKN86LAy8zanW08xNOrxI7VDdbtV1k6mf+wiV1W2Vo54HYEDIw0+jwmW/uKWatTyRo5AUsMc=
 rvm:
-- 2.4.3
-- 2.5.0
+- 2.3
+- 2.4
+- 2.5
+- 2.6
+- ruby-head
+matrix:
+  exclude:
+  - rvm: 2.3
+    env: RAILS_VERSION=6.0
+  - rvm: 2.4
+    env: RAILS_VERSION=6.0
+  allow_failures:
+  - rvm: ruby-head
 before_install:
 - gem install bundler -v 2.0.1 --no-doc
+- gem install bundler -v 1.17.3 --no-doc
+install: "./spec/bin/install.sh"
 script:
-- bundle exec rake spec
+- "./spec/bin/run_spec.sh"
 deploy:
   provider: rubygems
   api_key:
-    secure: XWpjZ+CzAqa9I/S9xJCFoCYJQ3cVp2Dz3DIWNjfC4H4lhxZokGA0FW/dKS2GFj/hadvw9gN5YYshyJegzm5I024QFexRxdBrmlVYCic/gqRIuK7hNp1IFeQJYK4j2s6HFcYnqn1sRT2EJQjdQVG/2+Dmv46xlpEPZH5yVnmQlIln28mYvXjPAjHgOLewgj7QEvt72jASd93X+YT30wGugVK0F+lWG75VFWBECe4kYebyNJZ+REX4aKnejtQwIhERD6vRHge3XZ2HQ0o0AZpqL8xK3ghjSuV3XOes01zvpg0qnsf4YA+ZaIRDmYPpCoWBoVFw2M4AyUUIHH0olojt0kDZvhhanDOk3pAxHaEN1bp0rs8oH5olXFnAXOm+4tls/ZyUPKCX/6UgibMVn99LOIxESx0fCf6N81rlHbD8lczLYDOkatozqoDYykt2I8mErYJjZSntwzRwRATkbWxb8Kgx60arUdWwzWXyNdN2Cz4Y0wnuY59X80/d7IddJoWClk2YSkyJqeASQytR2WfjRUkuCZnxOWjccajwRl5fOkA2md2Ttq92OZktqYaAz0l2FcVrxcPiGi5aQk+t8ygBtJx9ft2DQvyZQ1W8Sxdox06ql/WXDhq5i/gjq/jhN7Uu7Xs3G5UvxL+OO/2YQqy8rqb4IKuYAOLoNFmFDEQoN2Q=
+    secure: AVQi+tC5+HEoGgOKj/+/UeizOkwgVoB8zdPrd48/H9rx1KsAAmQ+2N9srOnrrEkm9I/bvHLOs0JpM96IiXFhztzrDefkaYQc1Zhu3tbWKZf6kuw0gabTMGhx3JsLoQiYRbJYea1qfrL0XlvQTxgkaa4zGJQaIBIZ97X7jlG5lVcys7JGjUFkozGJgS0t2HDffgDPLs3SiWR380Zvo4xcogw9tFHg5MuirZM/bXb9C/WhdDmKV9LbM8bTkJBjkZ0jbzKITtDJWSCXzdjRebLesTVN6F6cNWkwp2TumefgpQId4uGa5iUN8nXriqN890jjeZ3xHDq7xF0dRZgr8TyreocevCtNPCl+12c9ook0+mJn2GFTJL4W9BTuBGkBFekcQZ5MChWywcJ280iuPfX56Ilpt0wkCtWgB0k+k+eGTgEUv0iLykRFytNfiXr1oySG6mzxcUMf90IxfIKMydjFl8ZmAoTmZDfECtk59IW3PRwfHnNiNwmGMIGz9x9geO0wORWWnqdAwvHnQ7wMdScbSZ/VIPvpBdNe3rbhh4xAXXen+t1V0jvAlkBng9GLCwaRWuAsQG3fvRCbjWGxVmCLaQjUqIoJOtNVgeww+s5bXc8eVUtJ2UNRNnlN78lCWrRBhEfgRoyhVzl47vSZjhOE/2JlmQhpot9nwmMOz1h9wk8=
   gem: sorbet-rails
   on:
-    tags: true
     repo: chanzuckerberg/sorbet-rails
+    branch: setup_travis

data/CONTRIBUTING.md

@@ -0,0 +1,135 @@
+# Contributing to Sorbet Rails
+
+Thank you for taking the time to contribute to this project!
+
+This project adheres to the Contributor Covenant
+[code of conduct](https://github.com/chanzuckerberg/.github/tree/master/CODE_OF_CONDUCT.md).
+By participating, you are expected to uphold this code. Please report unacceptable behavior
+to opensource@chanzuckerberg.com.
+
+This project is licensed under the [MIT license](LICENSE.md).
+
+## Need Help?
+
+If you are trying to integrate Sorbet into your project, consider these venues:
+
+ * **Stack Overflow**: Try the [sorbet](https://stackoverflow.com/questions/tagged/sorbet)
+   and [sorbet + ruby-on-rails](https://stackoverflow.com/questions/tagged/sorbet+ruby-on-rails) tags
+ * **Slack**: [the Sorbet community](https://sorbet.org/en/community) includes
+   [#discuss](https://sorbet-ruby.slack.com/app_redirect?channel=discuss) and
+   [#rails](https://sorbet-ruby.slack.com/app_redirect?channel=rails) channels
+
+If you've come here to report an issue, you're in the right place!
+
+## Reporting Bugs and Adding Functionality
+
+We're excited you'd like to contribute to Sorbet Rails!
+
+When reporting a bug, please include:
+ * Steps to reproduce
+ * The versions of Ruby, Ruby on Rails, Sorbet, and this gem that you are using
+ * A test case, if you are able
+
+**If you believe you have found a security issue, please contact us at security@chanzuckerberg.com**
+rather than filing an issue here.
+
+When proposing new functionality, please include test coverage. We're also available in
+the Sorbet Slack [#rails](https://sorbet-ruby.slack.com/app_redirect?channel=rails) channel
+to discuss your idea before you get started, just to make sure everyone is on the same page.
+
+## Local Development
+
+1. Clone `sorbet-rails` locally:
+
+```sh
+❯ git clone https://github.com/chanzuckerberg/sorbet-rails.git
+```
+
+2. Point your project's Gemfile to your local clone:
+
+```
+# -- Gemfile --
+
+gem 'sorbet-rails', path: "~/sorbet-rails"
+```
+
+The most important files are:
+
+ * [`rbi/activerecord.rbi`](rbi/activerecord.rbi): The ActiveRecord RBI.
+   If you change anything in this file, it will be reflected when you run `srb tc`.
+
+ * [`lib/sorbet-rails/model_rbi_formatter.rb`](lib/sorbet-rails/model_rbi_formatter.rb):
+   Generates RBI files for models. You can regenerate these using `bundle exec rake rails_rbi:models`.
+
+ * [`lib/sorbet-rails/routes_rbi_formatter.rb`](lib/sorbet-rails/routes_rbi_formatter.rb):
+   Generates an RBI files for routes.  You can regenerate these using `bundle exec rake rails_rbi:routes`.
+
+## Tests
+
+Tests are written using [RSpec](https://rspec.info/). Each pull request is run against
+multiple versions of both Ruby and Ruby on Rails. A code coverage report is also generated.
+
+### Running Tests
+
+You can run tests using `bundle exec rake`.
+
+By default, tests will run against a Rails 5.2.x test application.
+
+To run the tests against all supported Rails branches, use:
+
+```sh
+❯ ./spec/bin/run_all_specs.sh
+```
+
+You can also switch to a version of Rails with `RAILS_VERSION`:
+
+```sh
+❯ RAILS_VERSION=4.2 ./spec/bin/run_spec.sh
+❯ RAILS_VERSION=5.1 ./spec/bin/run_spec.sh
+❯ RAILS_VERSION=5.2 ./spec/bin/run_spec.sh
+```
+
+#### Debugging
+
+It is possible to run only one file's tests:
+```sh
+❯ bundle exec rspec spec/model_rbi_formatter_spec.rb
+```
+Or a specific test in a file:
+```sh
+❯ bundle exec rspec spec/model_rbi_formatter_spec.rb:28
+```
+
+For debugging, you could use [byebug](https://github.com/deivid-rodriguez/byebug), which is
+installed in development mode. If you're not familiar with byebug, add `byebug` where you want
+execution to stop, which will then start a debugger. For more, check out the
+[byebug guide](https://github.com/deivid-rodriguez/byebug/blob/master/GUIDE.md).
+
+### Writing Tests
+
+Tests are in the `_spec.rb` files in the [`spec/`](spec/) directory.
+
+Rails apps are stored in [`spec/support/`](spec/support/). Code shared across Rails versions
+(models, views, controllers) are in [`spec/support/rails_shared/`](spec/support/rails_shared/)
+and symlinked to the individual Rails apps.
+
+To update the routes, see
+[`rails_shared/config/routes.rb`](spec/support/rails_shared/config/routes.rb)
+and [`rails_shared/app/controller/`](spec/support/rails_shared/app/controller/).
+
+To update the models, see [`rails_shared/app/models/`](spec/support/rails_shared/app/models/).
+Add database migrations to [`rails_shared/db/migrate/`](spec/support/rails_shared/db/migrate/)
+and remember to run `bundle exec rake db:migrate` in each application directory.
+
+#### Expected Output
+
+If your new tests make changes to the expected output, you can update the expected output
+by running:
+
+```sh
+❯ ./spec/bin/update_test_data.sh
+```
+
+Only do this once you're confident that your code is correct, because it will update
+the expected test data stored in [`spec/test_data/`](spec/test_data/) based on your current
+code, and all tests will then pass.

data/Gemfile

@@ -9,14 +9,32 @@ end
 
 rails_version = ENV["RAILS_VERSION"] || "default"
 
-rails =
-  case rails_version
-  when "master"
-    {github: "rails/rails"}
-  when "default"
-    ">= 5.2.3"
-  else
-    "~> #{rails_version}"
-  end
-
-gem "rails", rails
+case rails_version
+when "master"
+  gem "rails", {github: "rails/rails"}
+  gem "bundler", ">= 1.3.0"
+when "4.2"
+  gem "rails", "~> 4.2.11"
+  gem "bundler", "~> 1.17.3"
+  gem "sqlite3", "~> 1.3.6"
+when "5.0"
+  gem "rails", "~> 5.0.7"
+  gem "bundler", ">= 2.0"
+  gem "sqlite3", "~> 1.3.6"
+when "5.1"
+  gem "rails", "~> 5.1.7"
+  gem "bundler", ">= 2.0"
+  gem "sqlite3", "~> 1.4.1"
+when "5.2"
+  gem "rails", "~> 5.2.3"
+  gem "bundler", ">= 2.0"
+  gem "sqlite3", "~> 1.4.1"
+when "6.0"
+  gem "rails", "~> 6.0.0.rc1"
+  gem "bundler", ">= 2.0"
+  gem "sqlite3", "~> 1.4.1"
+else
+  gem "rails", ">= 5.2.3"
+  gem "bundler", ">= 2.0"
+  gem "sqlite3", "~> 1.4.1"
+end

data/README.md

@@ -1,16 +1,20 @@
 # sorbet-rails
 [![Gem Version](https://badge.fury.io/rb/sorbet-rails.svg)](https://badge.fury.io/rb/sorbet-rails)
-[![Build Status](https://travis-ci.org/chanzuckerberg/sorbet-rails.svg?branch=master)](https://travis-ci.org/chanzuckerberg/sorbet-rails)
+[![Build Status](https://travis-ci.com/chanzuckerberg/sorbet-rails.svg?branch=master)](https://travis-ci.com/chanzuckerberg/sorbet-rails)
 [![codecov](https://codecov.io/gh/chanzuckerberg/sorbet-rails/branch/master/graph/badge.svg)](https://codecov.io/gh/chanzuckerberg/sorbet-rails)
 
 A set of tools to make the [Sorbet](https://sorbet.org) typechecker work with Ruby on Rails seamlessly.
 
 This gem adds a few Rake tasks to generate Ruby Interface (RBI) files for dynamic methods generated by Rails. It also includes signatures for related Rails classes. The RBI files are added to a `sorbet/rails-rbi/` folder.
 
+`sorbet-rails` supports Rails 4.2 or later.
+
 ## Initial Setup
 
 1. Follow the steps [here](https://sorbet.org/docs/adopting) to set up the latest version of Sorbet, up to being able to run `srb tc`.
 
+Note: Do not add `sorbet-rails` to your Gemfile until after you've set up Sorbet. `sorbet-rails` adds RBI files that may [break](https://github.com/sorbet/sorbet/issues/1158) `srb init`.
+
 2. Add `sorbet-rails` to your Gemfile and install them with Bundler.
 
 ```
@@ -29,9 +33,9 @@ gem 'sorbet-rails'
 ❯ rake rails_rbi:models
 ```
 
-4. Auto-upgrade the typecheck level of files:
+4. Automatically upgrade each file's typecheck level:
 ```sh
-❯ srb tc --suggest-typed --typed=strict --error-white-list=7022 --autocorrect
+❯ srb rbi suggest-typed
 ```
 Because we've generated RBI files for routes and models, a lot more files should be typecheckable now.
 
@@ -64,11 +68,27 @@ The generation task currently creates the following signatures:
 - Named scopes
 - Model relation class
 
-```
-Skip method ... because it is not autogenerated by Rails.
-```
 ## Tips & Tricks
 
+### Overriding generated signatures
+
+`sorbet-rails` relies on Rails reflection to generate signatures. There are features this gem doesn't support yet such as [serialize](https://github.com/chanzuckerberg/sorbet-rails/issues/49) and [attribute custom types](https://github.com/chanzuckerberg/sorbet-rails/issues/16). The gem also doesn't know the signature of any methods you have overridden. However, it is possible to override the signatures that `sorbet-rails` generates.
+
+For example, here is how to override the signature for a method in a model:
+
+```ruby
+# -- app/models/model_name.rbi --
+
+# typed: strong
+class ModelName
+  sig { returns(T::Hash[...]) }
+  def field_name; end
+
+  sig { params(obj: T::Hash[....]).void }
+  def field_name=(obj); end
+end
+```
+
 ### `find`, `first` and `last`
 
 These 3 methods can either return a single nilable record or an array of records. Sorbet does not allow us to define multiple signatures for a function ([except stdlib](https://github.com/chanzuckerberg/sorbet-rails/issues/18)). It doesn't support defining one function signature that has varying returning value depending on the input parameter type. We opt to define the most commonly used signature for these methods, and monkey-patch new functions for the secondary use case.
@@ -123,9 +143,22 @@ Because Sorbet's initial setup tries to flag files at whichever typecheck level
 
 It is worth going through the list of files that is ignored and resolve them (and auto upgrade the types of other files; see [initial setup](#initial-setup) above). Usually this will make many more files able to be typechecked.
 
+### `unscoped` with a block
+
+The [`unscoped` method](https://apidock.com/rails/ActiveRecord/Scoping/Default/ClassMethods/unscoped) returns a `Relation` when no block is provided. When a block is provided, `unscoped` calls the block and returns its result, which could be any type.
+
+`sorbet-rails` chooses to define `unscoped` as returning a `Relation` because it's more common and more useful. If you want to use a block, either override the `unscoped` definition, or replace:
+```ruby
+Model.unscoped do … end
+```
+with:
+```ruby
+Model.unscoped.scoping do … end
+```
+
 ## Contributing
 
-Contributions and ideas are welcome! Please don't hesitate to open an issue or send a pull request to improve the functionality of this gem.
+Contributions and ideas are welcome! Please see [our contributing guide](CONTRIBUTING.md) and don't hesitate to open an issue or send a pull request to improve the functionality of this gem.
 
 This project adheres to the Contributor Covenant [code of conduct](https://github.com/chanzuckerberg/.github/tree/master/CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to opensource@chanzuckerberg.com.
 

data/lib/sorbet-rails/custom_finder_methods.rb

@@ -1,6 +1,6 @@
 module SorbetRails
   module CustomFinderMethods
-    def find_n(ids)
+    def find_n(*ids)
       find(ids)
     end
 

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -8,10 +8,12 @@ class ModelRbiFormatter
     @model_class = model_class
     @available_classes = available_classes
     @columns_hash = model_class.table_exists? ? model_class.columns_hash : {}
-    @generated_sigs = ActiveSupport::HashWithIndifferentAccess.new
+    @generated_instance_module_sigs = ActiveSupport::HashWithIndifferentAccess.new
+    @generated_instance_sigs = ActiveSupport::HashWithIndifferentAccess.new
     @generated_class_sigs = ActiveSupport::HashWithIndifferentAccess.new
     @generated_scope_sigs = ActiveSupport::HashWithIndifferentAccess.new
     @generated_querying_sigs = ActiveSupport::HashWithIndifferentAccess.new
+    @model_relation_class_name = "#{@model_class.name}::ActiveRecord_Relation"
     begin
       # Load all dynamic instance methods of this model by instantiating a fake model
       @model_class.new unless @model_class.abstract_class?
@@ -33,19 +35,30 @@ class ModelRbiFormatter
 
     @buffer << draw_module_header("#{@model_class.name}::#{MODEL_INSTANCE_MODULE_SUFFIX}")
     @model_class.instance_methods.sort.each do |method_name|
-      expected_sig = @generated_sigs[method_name]
+      expected_sig = @generated_instance_module_sigs[method_name]
       next unless expected_sig.present?
       method_obj = @model_class.instance_method(method_name)
       draw_method(method_name, method_obj, expected_sig)
     end
     @buffer << draw_module_or_class_footer
 
-    @buffer << draw_module_header("#{@model_class.name}::#{MODEL_CLASS_MODULE_SUFFIX}")
+    # TODO Enum methods need to be defined under the class definition because sorbet generates them
+    # in the hidden-definition.rbi
+    # When this issue is resolved, they might go away by running `srb rbi hidden-definitions`
+    # This is a sure way to make it work though.
+    # https://github.com/sorbet/sorbet/issues/1161
+    @buffer << draw_class_header("#{@model_class.name}") # ::#{MODEL_CLASS_MODULE_SUFFIX}")
+    @model_class.instance_methods.sort.each do |method_name|
+      expected_sig = @generated_instance_sigs[method_name]
+      next unless expected_sig.present?
+      method_obj = @model_class.instance_method(method_name)
+      draw_method(method_name, method_obj, expected_sig)
+    end
     @model_class.methods.sort.each do |method_name|
       expected_sig = @generated_class_sigs[method_name]
       next unless expected_sig.present?
       method_obj = @model_class.method(method_name)
-      draw_method(method_name, method_obj, expected_sig)
+      draw_method(method_name, method_obj, expected_sig, is_class_method: true)
     end
     @buffer << draw_module_or_class_footer
 
@@ -71,19 +84,25 @@ class ModelRbiFormatter
     @buffer.join("\n")
   end
 
-  def draw_method(method_name, method_obj, expected_sig)
+  def draw_method(method_name, method_obj, expected_sig, is_class_method: false)
     if !method_obj.present?
       # not very actionable because this could be a method in a newer version of Rails
       # puts "Skip method '#{method_name}' because there is no matching method object."
       return
     end
-    @buffer << generate_method_sig(method_name, expected_sig).indent(2)
+    @buffer << generate_method_sig(method_name, expected_sig, is_class_method).indent(2)
   end
 
   def populate_activerecord_querying_methods
     # All is a named scope that most method from ActiveRecord::Querying delegate to
     # rails/activerecord/lib/active_record/querying.rb:21
-    @generated_scope_sigs["all"] = { ret: "#{@model_class.name}::Relation" }
+    @generated_scope_sigs["all"] = { ret: @model_relation_class_name }
+    @generated_scope_sigs["unscoped"] = {
+      ret: @model_relation_class_name,
+      args: [
+        { name: :block, arg_type: :block, value_type: 'T.nilable(T.proc.void)' },
+      ]
+    }
     # It's not possible to typedef all methods in ActiveRecord::Querying module to have the
     # matching type. By generating model-specific sig, we can typedef these methods to return
     # <Model>::Relation class.
@@ -99,7 +118,7 @@ class ModelRbiFormatter
           {name: :args, arg_type: :rest, value_type: 'T.untyped'},
           {name: :block, arg_type: :block, value_type: 'T.nilable(T.proc.void)'},
         ],
-        ret: "#{@model_class.name}::Relation",
+        ret: @model_relation_class_name,
       }
     end
   end
@@ -117,7 +136,7 @@ class ModelRbiFormatter
       next unless source_file.include?('lib/active_record/scoping/named.rb')
       @generated_scope_sigs[method_name] = {
         args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
-        ret: "#{@model_class.name}::Relation",
+        ret: @model_relation_class_name,
       }
     end
   end
@@ -128,7 +147,7 @@ class ModelRbiFormatter
         # enum attribute is treated differently
         assignable_type = "T.any(Integer, String, Symbol)"
         assignable_type = "T.nilable(#{assignable_type})" if column_def.null
-        @generated_sigs.merge!({
+        @generated_instance_module_sigs.merge!({
           "#{column_name}" => { ret: "String" },
           "#{column_name}=" => {
             args: [ name: :value, arg_type: :req, value_type: assignable_type],
@@ -136,7 +155,7 @@ class ModelRbiFormatter
         })
       else
         column_type = type_for_column_def(column_def)
-        @generated_sigs.merge!({
+        @generated_instance_module_sigs.merge!({
           "#{column_name}" => { ret: column_type },
           "#{column_name}=" => {
             args: [ name: :value, arg_type: :req, value_type: column_type ],
@@ -144,12 +163,10 @@ class ModelRbiFormatter
         })
       end
 
-      if column_def.type == :boolean
-        @generated_sigs["#{column_name}?"] = {
-          ret: "T::Boolean",
-          args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
-        }
-      end
+      @generated_instance_module_sigs["#{column_name}?"] = {
+        ret: "T::Boolean",
+        args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
+      }
     end
   end
 
@@ -163,7 +180,7 @@ class ModelRbiFormatter
 
   def populate_single_assoc_getter_setter(assoc_name, reflection)
     # TODO allow people to specify the possible values of polymorphic associations
-    assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : reflection.class_name
+    assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : "::#{reflection.klass.name}"
     assoc_type = "T.nilable(#{assoc_class})"
     if reflection.belongs_to?
       # if this is a belongs_to connection, we may be able to detect whether
@@ -174,7 +191,7 @@ class ModelRbiFormatter
       end
     end
 
-    @generated_sigs.merge!({
+    @generated_instance_sigs.merge!({
       "#{assoc_name}" => { ret: assoc_type },
       "#{assoc_name}=" => {
         args: [ name: :value, arg_type: :req, value_type: assoc_type ],
@@ -184,11 +201,11 @@ class ModelRbiFormatter
 
   def populate_collection_assoc_getter_setter(assoc_name, reflection)
     # TODO allow people to specify the possible values of polymorphic associations
-    assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : reflection.class_name
+    assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : "::#{reflection.klass.name}"
     relation_class = relation_should_be_untyped?(reflection) ?
-      "ActiveRecord::Associations::CollectionProxy[T.untyped]" :
-      "#{assoc_class}::CollectionProxy"
-    @generated_sigs.merge!({
+      "ActiveRecord::Associations::CollectionProxy" :
+      "#{assoc_class}::ActiveRecord_Associations_CollectionProxy"
+    @generated_instance_sigs.merge!({
       "#{assoc_name}" => { ret: relation_class },
       "#{assoc_name}=" => {
         args: [ name: :value, arg_type: :req, value_type: "T.any(T::Array[#{assoc_class}], #{relation_class})" ],
@@ -200,26 +217,32 @@ class ModelRbiFormatter
     @model_class.defined_enums.each do |enum_name, enum_hash|
       @generated_class_sigs["#{enum_name.pluralize}"] = { ret: "T::Hash[T.any(String, Symbol), Integer]"}
       enum_hash.keys.each do |enum_val|
-        @generated_sigs["#{enum_val}?"] = { ret: "T::Boolean" }
+        @generated_instance_module_sigs["#{enum_val}?"] = { ret: "T::Boolean" }
+        @generated_instance_module_sigs["#{enum_val}!"] = { ret: nil }
         @generated_scope_sigs["#{enum_val}"] = {
           args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
-          ret: "#{@model_class.name}::Relation",
+          ret: @model_relation_class_name,
+        }
+        # force generating these methods because sorbet's hidden-definitions generate & override them
+        @generated_class_sigs["#{enum_val}"] = {
+          args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
+          ret: @model_relation_class_name,
         }
       end
     end
   end
 
   def assoc_should_be_untyped?(reflection)
-    polymorphic_assoc?(reflection) || !Object.const_defined?(reflection.class_name)
+    polymorphic_assoc?(reflection) || !@available_classes.include?(reflection.klass.name)
   end
 
   def relation_should_be_untyped?(reflection)
     # only type the relation we'll generate
-    assoc_should_be_untyped?(reflection) || !@available_classes.include?(reflection.class_name)
+    assoc_should_be_untyped?(reflection) || !@available_classes.include?(reflection.klass.name)
   end
 
   def polymorphic_assoc?(reflection)
-    reflection.through_reflection? ?
+    reflection.through_reflection ?
       polymorphic_assoc?(reflection.source_reflection) :
       reflection.polymorphic?
   end
@@ -232,13 +255,13 @@ class ModelRbiFormatter
       # Please rerun rake rails_rbi:models to regenerate.
       # typed: strong
 
-      class #{@model_class.name}::Relation < ActiveRecord::Relation
+      class #{@model_relation_class_name} < ActiveRecord::Relation
         include #{@model_class.name}::#{MODEL_RELATION_SHARED_MODULE_SUFFIX}
         extend T::Generic
         Elem = type_member(fixed: #{@model_class.name})
       end
 
-      class #{@model_class.name}::CollectionProxy < ActiveRecord::Associations::CollectionProxy
+      class #{@model_class.name}::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
         include #{@model_class.name}::#{MODEL_RELATION_SHARED_MODULE_SUFFIX}
         extend T::Generic
         Elem = type_member(fixed: #{@model_class.name})
@@ -248,8 +271,7 @@ class ModelRbiFormatter
         extend T::Sig
         extend T::Generic
         extend #{@model_class.name}::#{MODEL_RELATION_SHARED_MODULE_SUFFIX}
-        extend #{@model_class.name}::ClassMethods
-        include #{@model_class.name}::InstanceMethods
+        include #{@model_class.name}::#{MODEL_INSTANCE_MODULE_SUFFIX}
         Elem = type_template(fixed: #{@model_class.name})
       end
     MESSAGE
@@ -268,14 +290,18 @@ class ModelRbiFormatter
     MESSAGE
   end
 
-  def generate_column_methods(buffer)
-    @columns_hash.each do |column_name, column_def|
-      buffer << draw_column_methods(column_name, column_def)
-    end
+  def draw_class_header(name)
+    <<~MESSAGE
+      class #{name}
+        extend T::Sig
+    MESSAGE
   end
 
   def type_for_column_def(column_def)
-    cast_type = ActiveRecord::Base.connection.lookup_cast_type_from_column(column_def)
+    cast_type = ActiveRecord::Base.connection.respond_to?(:lookup_cast_type_from_column) ?
+      ActiveRecord::Base.connection.lookup_cast_type_from_column(column_def) :
+      column_def.cast_type
+
     strict_type = active_record_type_to_sorbet_type(cast_type)
 
     if column_def.respond_to?(:array?) && column_def.array?
@@ -300,20 +326,22 @@ class ModelRbiFormatter
       Time
     when ActiveRecord::Type::BigInteger, ActiveRecord::Type::Integer, ActiveRecord::Type::DecimalWithoutScale, ActiveRecord::Type::UnsignedInteger
       Integer
-    when ActiveRecord::Enum::EnumType, ActiveRecord::Type::Binary, ActiveRecord::Type::String, ActiveRecord::Type::Text
+    when ActiveRecord::Type::Binary, ActiveRecord::Type::String, ActiveRecord::Type::Text
       String
     else
-      # Json type is only supported in Rails 5.2.3 and above
+      # Json type is only supported in Rails 5.2 and above
       case
       when Object.const_defined?('ActiveRecord::Type::Json') && klass.is_a?(ActiveRecord::Type::Json)
         "T.any(Array, T::Boolean, Float, Hash, Integer, String)"
+      when Object.const_defined?('ActiveRecord::Enum::EnumType') && klass.is_a?(ActiveRecord::Enum::EnumType)
+        String
       else
         "T.untyped"
       end
     end
   end
 
-  def generate_method_sig(method_name, generated_method_def)
+  def generate_method_sig(method_name, generated_method_def, is_class_method)
     # generated_method_def:
     # {
     # .  ret: <return_type>
@@ -339,18 +367,21 @@ class ModelRbiFormatter
         prefix = ""
         prefix = "*" if arg_def[:arg_type] == :rest
         prefix = "**" if arg_def[:arg_type] == :keyrest
+        prefix = "&" if arg_def[:arg_type] == :block
 
         "#{prefix}#{arg_def[:name]}"
       }.join(", ")
     end
 
+    method_prefix = is_class_method ? 'self.' : ''
+
     return_type = generated_method_def[:ret] ?
       "returns(#{generated_method_def[:ret]})" :
       "void"
 
     <<~MESSAGE
       sig { #{param_sig}#{return_type} }
-      def #{method_name}(#{param_def}); end
+      def #{method_prefix}#{method_name}(#{param_def}); end
     MESSAGE
   end
 end