sorbet-rails 0.5.8.1 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d15a660642f3208ed9262e89d7135ef6491c5744febd95838a2f1e3e49da2d5
-  data.tar.gz: a276904cf439043622ff87e05a9048600afa497c768e7237b7499f84ed7b47ee
+  metadata.gz: bebc32701fb31995a1cf7f25ae7c2c7a9088347e8665dad3f182474483f03cc8
+  data.tar.gz: 8ae391dbadcc26831eebfef0969834969fe7c77ca8dd203f9ef05a7be26c19e0
 SHA512:
-  metadata.gz: 50407eaa9170838b6060a94d1a31b5558cd4b6b70e90a508dd5bd366873e063a91d8cb2e32c11cf5ccc1410f9756d15f1fdecf5596e19a0a9e2080bf0deac763
-  data.tar.gz: 87acca40218683be192a32006e6339d0829d821d28225c9f7311cbd2ae88199e13748461c4cf13d2698dec86020cb8fac6fe4fe08b66ebb0a0852e7e10744e5d
+  metadata.gz: 79759ed27498ebdced14582be0acfd6eef70c088a0eacf31335c9043cd43c22f5dc3b7f7638ea2c5ca1ba73e7209bc5cea3780abcae7ba427572050ee7414c39
+  data.tar.gz: a99f4c32fd69d120cbad6efc954c11fa8ad9cfbc6adb4c7e6e72422129984e25904134d725dfc8aec96b47dab9193085352a4fd55858124a5906ae41c8b42498

data/.travis.yml

@@ -16,7 +16,7 @@ rvm:
 matrix:
   include:
   - rvm: 2.5
-    env: RAILS_VERSION=5.2 SORBET_VERSION=0.4.4755
+    env: RAILS_VERSION=5.2 SORBET_VERSION=0.4.4929
   exclude:
   - rvm: 2.3
     env: RAILS_VERSION=6.0

data/README.md

@@ -19,16 +19,15 @@ This gem adds a few Rake tasks to generate Ruby Interface (RBI) files for dynami
 
 ```
 # -- Gemfile --
-
 gem 'sorbet-rails'
 ```
 
+Add `sorbet-rails` to the [`:default` group](https://bundler.io/v2.0/guides/groups.html) because of "Features Provided at Runtime" below.
+
 ```sh
 ❯ bundle install
 ```
 
-Warning: *don't* add `sorbet-rails` to a specific environment group (eg. `development` only). `sorbet-rails` adds a bunch of helper methods to your Rails runtime as well as generators for RBI files. You'll want to run the gem in all environments.
-
 3. Generate RBI files for your routes, models, etc
 ```sh
 ❯ rake rails_rbi:routes
@@ -48,7 +47,7 @@ Warning: *don't* add `sorbet-rails` to a specific environment group (eg. `develo
 ```
 Because we've generated RBI files for routes, models, and helpers, a lot more files should be typecheckable now. Many methods in `hidden.rbi` may be removed because they are now typed.
 
-## Type-checking Rails code
+## Static RBI Generation
 
 ### Models
 
@@ -148,6 +147,26 @@ Since mailing action methods is based on instance methods defined in a mailer cl
 - If not, all the params in the mailing action method will be T.untyped.
 - For return type though, the mailing action method will return `ActionMailer::MessageDelivery` instead of the return type of the instance method.
 
+## Runtime Features
+
+In addition to features provided by the static generator, `sorbet-rails` can
+provide additional features when `require`d. This is why the installation
+instructions specify that `sorbet-rails` should be placed in the [`:default`
+group](https://bundler.io/v2.0/guides/groups.html) of the `Gemfile`, not a
+specific environment group (eg. `development` only).
+
+- Relation class: Making the relations available at runtime (they are normally private constants, the gem makes them public)
+  - Examples: `User::ActiveRecord_Relation`, `User::ActiveRecord_AssociationRelation`
+- Model: `find_n`, `first_n`, `last_n` are the methods we added. `pluck_to_tstruct` as well.
+- Controller: adding `fetch_typed` and `require_typed`
+
+In addition to `require`ing `sorbet-rails`, you must also run
+`rake rails_rbi:custom`, which will produce the RBI for these runtime features.
+
+Discussion:
+[#211](https://github.com/chanzuckerberg/sorbet-rails/issues/211),
+[#214](https://github.com/chanzuckerberg/sorbet-rails/pull/214#issuecomment-546505485)
+
 ## Tips & Tricks
 
 ### Overriding generated signatures
@@ -342,6 +361,8 @@ These are the currently-supported gems and their symbolized names:
 | [Kaminari]   | `:kaminari`    |
 | [PgSearch]   | `:pg_search`   |
 | [Shrine]     | `:shrine`      |
+| [active_flag]| `:active_flag` |
+| [Paperclip]  | `:paperclip` |
 
 You can also configure the core model plugins if needed. The default plugins are defined in the [config](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/config.rb). For the full list of plugin symbols, check out [here](https://github.com/chanzuckerberg/sorbet-rails/blob/master/lib/sorbet-rails/model_plugins/plugins.rb).
 
@@ -351,6 +372,8 @@ You can also configure the core model plugins if needed. The default plugins are
 [FriendlyId]: https://github.com/norman/friendly_id
 [ElasticSearch]: https://github.com/elastic/elasticsearch-rails
 [Shrine]: https://github.com/shrinerb/shrine
+[active_flag]: https://github.com/kenn/active_flag
+[Paperclip]: https://github.com/thoughtbot/paperclip
 
 ## Contributing
 

data/lib/bundled_rbi/active_record_relation.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+class ActiveRecord::Relation
+  sig { params(args: T.untyped).returns(Elem) }
+  def find(*args); end
+
+  sig { params(args: T.untyped).returns(T.nilable(Elem)) }
+  def find_by(*args); end
+
+  sig { params(args: T.untyped).returns(Elem) }
+  def find_by!(*args); end
+
+  sig { returns(T.nilable(Elem)) }
+  def first; end
+
+  sig { returns(Elem) }
+  def first!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second; end
+
+  sig { returns(Elem) }
+  def second!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third; end
+
+  sig { returns(Elem) }
+  def third!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third_to_last; end
+
+  sig { returns(Elem) }
+  def third_to_last!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second_to_last; end
+
+  sig { returns(Elem) }
+  def second_to_last!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def last; end
+
+  sig { returns(Elem) }
+  def last!; end
+
+  sig { override.params(block: T.proc.params(e: Elem).void).returns(T::Array[Elem]) }
+  def each(&block); end
+
+  sig { params(level: T.nilable(Integer)).returns(T::Array[Elem]) }
+  def flatten(level); end
+
+  sig { returns(T::Array[Elem]) }
+  def to_a; end
+
+  sig do
+    type_parameters(:U).params(
+        blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
+    )
+    .returns(T::Array[T.type_parameter(:U)])
+  end
+  def map(&blk); end
+
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def exists?(conditions = nil); end
+
+  sig { returns(T::Boolean) }
+  def any?; end
+
+  sig { returns(T::Boolean) }
+  def many?; end
+
+  sig { returns(T::Boolean) }
+  def none?; end
+
+  sig { returns(T::Boolean) }
+  def one?; end
+end

data/lib/sorbet-rails/gem_plugins/active_flag_plugin.rb

@@ -0,0 +1,47 @@
+# typed: strict
+class ActiveFlagPlugin < SorbetRails::ModelPlugins::Base
+  sig { params(root: Parlour::RbiGenerator::Namespace).void.override }
+  def generate(root)
+    # method added here: https://github.com/kenn/active_flag/blob/master/lib/active_flag.rb#L13
+    return unless model_class.respond_to?(:active_flags)
+
+    module_name = self.model_module_name("GeneratedActiveFlagMethods")
+    module_rbi = root.create_module(module_name)
+    module_rbi.create_extend("T::Sig")
+
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(module_name)
+
+    module_rbi.create_method(
+      "active_flags",
+      return_type: "T::Hash[Symbol, ActiveFlag::Definition]",
+      class_method: true
+    )
+
+    active_flag_keys(model_class).each do |flag|
+      module_rbi.create_method(
+        flag.to_s,
+        return_type: "::ActiveFlag::Value"
+      )
+
+      module_rbi.create_method(
+        "#{flag}=",
+        parameters: [
+          Parameter.new("value", type: "T::Array[Symbol]")
+        ],
+        return_type: nil
+      )
+
+      module_rbi.create_method(
+        flag.to_s.pluralize,
+        return_type: "::ActiveFlag::Definition",
+        class_method: true
+      )
+    end
+  end
+
+  sig { params(model_class: T.class_of(ActiveRecord::Base)).returns(T::Array[Symbol]) }
+  def active_flag_keys(model_class)
+    T.unsafe(model_class).active_flags.keys
+  end
+end

data/lib/sorbet-rails/gem_plugins/kaminari_plugin.rb

@@ -1,7 +1,6 @@
 # typed: strict
 class KaminariPlugin < SorbetRails::ModelPlugins::Base
   # Kaminari generates a dynamic `page` method on ActiveRecord relations.
-  # https://github.com/kaminari/kaminari/blob/c5186f5d9b7f23299d115408e62047447fd3189d/kaminari-activerecord/lib/kaminari/activerecord/active_record_model_extension.rb#L15
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
     return unless @model_class.include?(::Kaminari::ActiveRecordModelExtension)
@@ -9,6 +8,7 @@ class KaminariPlugin < SorbetRails::ModelPlugins::Base
     # Get the configured Kaminari page method name, or fall back to 'page' if necessary.
     page_method = T.unsafe(::Kaminari).config.page_method_name || 'page'
 
+    # https://github.com/kaminari/kaminari/blob/c5186f5d9b7f23299d115408e62047447fd3189d/kaminari-activerecord/lib/kaminari/activerecord/active_record_model_extension.rb#L15
     add_relation_query_method(
       root,
       page_method.to_s,
@@ -16,5 +16,24 @@ class KaminariPlugin < SorbetRails::ModelPlugins::Base
         Parameter.new('num', type: 'T.nilable(Integer)', default: 'nil')
       ],
     )
+
+    # https://github.com/kaminari/kaminari/blob/c5186f5d9b7f23299d115408e62047447fd3189d/kaminari-core/lib/kaminari/models/page_scope_methods.rb#L7
+    add_relation_query_method(
+      root,
+      "per",
+      parameters: [
+        Parameter.new('num', type: 'Integer'),
+        Parameter.new('max_per_page', type: 'T.nilable(Integer)', default: 'nil')
+      ],
+    )
+
+    # https://github.com/kaminari/kaminari/blob/c5186f5d9b7f23299d115408e62047447fd3189d/kaminari-core/lib/kaminari/models/page_scope_methods.rb#L27
+    add_relation_query_method(
+      root,
+      "padding",
+      parameters: [
+        Parameter.new('num', type: 'Integer')
+      ],
+    )
   end
 end

data/lib/sorbet-rails/gem_plugins/paperclip_plugin.rb

@@ -0,0 +1,33 @@
+# typed: strict
+class PaperclipPlugin < SorbetRails::ModelPlugins::Base
+  sig { params(root: Parlour::RbiGenerator::Namespace).void.override }
+  def generate(root)
+    # method added here: https://github.com/thoughtbot/paperclip/blob/v5.2.1/lib/paperclip/has_attached_file.rb#L110
+
+    return unless model_class.respond_to?(:attachment_definitions)
+
+    module_name = self.model_module_name("GeneratedPaperclipMethods")
+    module_rbi = root.create_module(module_name)
+    module_rbi.create_extend("T::Sig")
+
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(module_name)
+
+    T.unsafe(::Paperclip::AttachmentRegistry).names_for(model_class).each do |attachment|
+      # https://github.com/thoughtbot/paperclip/blob/v5.2.1/lib/paperclip/has_attached_file.rb#L42
+      module_rbi.create_method(
+        attachment.to_s,
+        return_type: "::Paperclip::Attachment"
+      )
+
+      # https://github.com/thoughtbot/paperclip/blob/v5.2.1/lib/paperclip/attachment.rb#L100
+      module_rbi.create_method(
+        "#{attachment}=",
+        parameters: [
+          Parameter.new("uploaded_file", type: "T.untyped") # could be a variety of things
+        ],
+        return_type: nil
+      )
+    end
+  end
+end

data/lib/sorbet-rails/model_plugins/active_record_assoc.rb

@@ -56,13 +56,29 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
     # optional (via `optional` or `!required` or `!belongs_to_required_by_default`)
     return false if !reflection.belongs_to?
 
-    if reflection.options.key?(:required)
-      !!reflection.options[:required]
-    elsif reflection.options.key?(:optional)
-      !reflection.options[:optional]
-    else
-      !!reflection.active_record.belongs_to_required_by_default
+    rails_required_config =
+      if reflection.options.key?(:required)
+        !!reflection.options[:required]
+      elsif reflection.options.key?(:optional)
+        !reflection.options[:optional]
+      else
+        !!reflection.active_record.belongs_to_required_by_default
+      end
+
+    column_def = @columns_hash[reflection.foreign_key.to_s]
+    db_required_config = column_def && !column_def.null
+
+    if rails_required_config && !db_required_config
+      puts "Warning: belongs_to association #{reflection.name} is required at the application
+        level but **nullable** at the DB level. Add a constraint at the DB level
+        (using `null: false` and foreign key constraint) to ensure it is enforced.".squish!
+    elsif !rails_required_config && db_required_config
+      puts "Warning: belongs_to association #{reflection.name} is specified as not-null at the
+        DB level but **not required** at the application level. Add a constraint at the app level
+        (using `optional: false`) as a validation hint to Rails.".squish!
     end
+
+    rails_required_config || db_required_config
   end
 
   sig do

data/lib/sorbet-rails/model_plugins/active_record_attribute.rb

@@ -131,15 +131,23 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
 
   sig { params(column_type: Object).returns(String) }
   def value_type_for_attr_writer(column_type)
-    assignable_time_types = [DateTime, Date, Time, ActiveSupport::TimeWithZone].map(&:to_s)
-
     # it's safe - and convenient - to assign any "time like" object to a time zone
     # aware attribute because Rails will cast it to a `ActiveSupport::TimeWithZone`
     # (so rereading the attribute will always return the `TimeWithZone` type)
+    assignable_time_types = [DateTime, Date, Time, ActiveSupport::TimeWithZone].map(&:to_s)
+
+    # same thing applies with the many types that respond to `#to_i` or `#to_f`
+    assignable_numeric_types = [Integer, Float, ActiveSupport::Duration]
+
+    # TODO: this could be a lot tidier
     if column_type == ActiveSupport::TimeWithZone
       "T.any(#{assignable_time_types.join(', ')})"
     elsif column_type == "T.nilable(ActiveSupport::TimeWithZone)"
       "T.nilable(T.any(#{assignable_time_types.join(', ')}))"
+    elsif ["T.nilable(Float)", "T.nilable(Integer)"].include?(column_type)
+      "T.nilable(T.any(#{assignable_numeric_types.join(', ')}))"
+    elsif ["Float", "Integer"].include?(column_type.to_s)
+      "T.any(#{assignable_numeric_types.join(', ')})"
     elsif column_type == String
       'T.any(String, Symbol)'
     else

data/lib/sorbet-rails/model_plugins/active_record_finder_methods.rb

@@ -8,7 +8,7 @@ class SorbetRails::ModelPlugins::ActiveRecordFinderMethods < SorbetRails::ModelP
     create_finder_methods_for(model_class_rbi, class_method: true)
 
     model_relation_class_rbi = root.create_class(self.model_relation_class_name)
-    create_finder_methods_for(model_relation_class_rbi, class_method: false)
+    create_finder_methods_for(model_relation_class_rbi, class_method: false, include_methods_that_return_self: false)
 
     model_assoc_proxy_class_rbi = root.create_class(self.model_assoc_proxy_class_name)
     create_finder_methods_for(model_assoc_proxy_class_rbi, class_method: false)
@@ -17,46 +17,57 @@ class SorbetRails::ModelPlugins::ActiveRecordFinderMethods < SorbetRails::ModelP
     create_finder_methods_for(model_assoc_relation_rbi, class_method: false)
   end
 
-  sig { params(class_rbi: Parlour::RbiGenerator::ClassNamespace, class_method: T::Boolean).void }
-  def create_finder_methods_for(class_rbi, class_method:)
-    class_rbi.create_method(
-      "find",
-      parameters: [ Parameter.new("*args", type: "T.untyped") ],
-      return_type: self.model_class_name,
-      class_method: class_method,
-    )
-    class_rbi.create_method(
-      "find_by",
-      parameters: [ Parameter.new("*args", type: "T.untyped") ],
-      return_type: "T.nilable(#{self.model_class_name})",
-      class_method: class_method,
-    )
-    class_rbi.create_method(
-      "find_by!",
-      parameters: [ Parameter.new("*args", type: "T.untyped") ],
-      return_type: self.model_class_name,
-      class_method: class_method
-    )
+  sig do
+    params(
+      class_rbi: Parlour::RbiGenerator::ClassNamespace,
+      class_method: T::Boolean,
+      include_methods_that_return_self: T::Boolean
+    ).void
+  end
+  def create_finder_methods_for(class_rbi, class_method:, include_methods_that_return_self: true)
+    # The intent of this is to prevent these methods from being generated
+    # unnecessarily when T.attached_class or Elem can be used to reduce
+    # the number of method signatures that have to be generated.
+    if include_methods_that_return_self
+      class_rbi.create_method(
+        "find",
+        parameters: [ Parameter.new("*args", type: "T.untyped") ],
+        return_type: self.model_class_name,
+        class_method: class_method,
+      )
+      class_rbi.create_method(
+        "find_by",
+        parameters: [ Parameter.new("*args", type: "T.untyped") ],
+        return_type: "T.nilable(#{self.model_class_name})",
+        class_method: class_method,
+      )
+      class_rbi.create_method(
+        "find_by!",
+        parameters: [ Parameter.new("*args", type: "T.untyped") ],
+        return_type: self.model_class_name,
+        class_method: class_method
+      )
 
-    ["first", "second", "third", "third_to_last", "second_to_last", "last"].
-      each do |method_name|
-        create_finder_method_pair(class_rbi, method_name, class_method)
-      end
+      ["first", "second", "third", "third_to_last", "second_to_last", "last"].
+        each do |method_name|
+          create_finder_method_pair(class_rbi, method_name, class_method)
+        end
 
-    # Checker methods
-    class_rbi.create_method(
-      "exists?",
-      parameters: [ Parameter.new("conditions", type: "T.untyped", default: "nil") ],
-      return_type: "T::Boolean",
-      class_method: class_method,
-    )
-    ["any?", "many?", "none?", "one?"].each do |method_name|
+      # Checker methods
       class_rbi.create_method(
-        method_name,
-        parameters: [ Parameter.new("*args", type: "T.untyped") ],
+        "exists?",
+        parameters: [ Parameter.new("conditions", type: "T.untyped", default: "nil") ],
         return_type: "T::Boolean",
         class_method: class_method,
       )
+      ["any?", "many?", "none?", "one?"].each do |method_name|
+        class_rbi.create_method(
+          method_name,
+          parameters: [ Parameter.new("*args", type: "T.untyped") ],
+          return_type: "T::Boolean",
+          class_method: class_method,
+        )
+      end
     end
   end
 

data/lib/sorbet-rails/model_plugins/enumerable_collections.rb

@@ -4,10 +4,10 @@ class SorbetRails::ModelPlugins::EnumerableCollections < SorbetRails::ModelPlugi
 
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
-    # model relation & association proxy are enumerable
+    # model relation, assocation relation, & association proxy are enumerable
     # we need to implement "each" in these methods so that they work
     model_relation_class_rbi = root.create_class(self.model_relation_class_name)
-    create_enumerable_methods_for(model_relation_class_rbi)
+    create_enumerable_methods_for(model_relation_class_rbi, include_methods: false)
 
     model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
     create_enumerable_methods_for(model_assoc_relation_rbi)
@@ -28,38 +28,44 @@ class SorbetRails::ModelPlugins::EnumerableCollections < SorbetRails::ModelPlugi
     end
   end
 
-  sig { params(class_rbi: Parlour::RbiGenerator::ClassNamespace).void }
-  def create_enumerable_methods_for(class_rbi)
+  sig { params(class_rbi: Parlour::RbiGenerator::ClassNamespace, include_methods: T::Boolean).void }
+  def create_enumerable_methods_for(class_rbi, include_methods: true)
     class_rbi.create_include("Enumerable")
-    class_rbi.create_method(
-      "each",
-      parameters: [
-        Parameter.new("&block", type: "T.proc.params(e: #{self.model_class_name}).void")
-      ],
-      return_type: "T::Array[#{self.model_class_name}]",
-      implementation: true,
-    )
-    class_rbi.create_method(
-      "flatten",
-      parameters: [ Parameter.new("level", type: "T.nilable(Integer)") ],
-      return_type: "T::Array[#{self.model_class_name}]",
-    )
-    # this is an escape hatch when there are conflicts in signatures of Enumerable & ActiveRecord
-    class_rbi.create_method(
-      "to_a",
-      return_type: "T::Array[#{self.model_class_name}]",
-    )
-    # TODO use type_parameters(:U) when parlour supports it
-    class_rbi.create_arbitrary(
-      code: <<~RUBY
-        sig do
-          type_parameters(:U).params(
-              blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
-          )
-          .returns(T::Array[T.type_parameter(:U)])
-        end
-        def map(&blk); end
-      RUBY
-    )
+
+    # An escape hatch that prevents these methods from being added unnecessarily.
+    # In certain cases, we can remove these from the classes because they can
+    # be generalized to use Elem in a superclass instead.
+    if include_methods
+      class_rbi.create_method(
+        "each",
+        parameters: [
+          Parameter.new("&block", type: "T.proc.params(e: #{self.model_class_name}).void")
+        ],
+        return_type: "T::Array[#{self.model_class_name}]",
+        implementation: true,
+      )
+      class_rbi.create_method(
+        "flatten",
+        parameters: [ Parameter.new("level", type: "T.nilable(Integer)") ],
+        return_type: "T::Array[#{self.model_class_name}]",
+      )
+      # this is an escape hatch when there are conflicts in signatures of Enumerable & ActiveRecord
+      class_rbi.create_method(
+        "to_a",
+        return_type: "T::Array[#{self.model_class_name}]",
+      )
+      # TODO use type_parameters(:U) when parlour supports it
+      class_rbi.create_arbitrary(
+        code: <<~RUBY
+          sig do
+            type_parameters(:U).params(
+                blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
+            )
+            .returns(T::Array[T.type_parameter(:U)])
+          end
+          def map(&blk); end
+        RUBY
+      )
+    end
   end
 end

data/lib/sorbet-rails/model_plugins/plugins.rb

@@ -78,6 +78,12 @@ module SorbetRails::ModelPlugins
     when :elastic_search
       require('sorbet-rails/gem_plugins/elastic_search_plugin')
       ElasticSearchPlugin
+    when :active_flag
+      require('sorbet-rails/gem_plugins/active_flag_plugin')
+      ActiveFlagPlugin
+    when :paperclip
+      require('sorbet-rails/gem_plugins/paperclip_plugin')
+      PaperclipPlugin
     else
       raise UnrecognizedPluginName.new(
         "Unrecognized plugin with name: #{plugin_name}. Please check available plugins in the

data/lib/sorbet-rails/routes_rbi_formatter.rb

@@ -31,6 +31,10 @@ class SorbetRails::RoutesRbiFormatter
     @parlour.root.create_module('ActionView::Helpers') do |mod|
       mod.create_include('GeneratedUrlHelpers')
     end
+
+    @parlour.root.create_class('ActionMailer::Base') do |mod|
+      mod.create_include('GeneratedUrlHelpers')
+    end
   end
 
   sig { params(routes: T.untyped, filter: T.untyped).void }

data/lib/sorbet-rails/tasks/rails_rbi.rake

@@ -37,6 +37,7 @@ namespace :rails_rbi do
     copy_bundled_rbi('type_assert.rbi')
     copy_bundled_rbi('parameters.rbi')
     copy_bundled_rbi('pluck_to_tstruct.rbi')
+    copy_bundled_rbi('active_record_relation.rbi')
   end
 
   desc "Generate rbis for rails models. Pass models name to regenerate rbi for only the given models."
@@ -113,7 +114,7 @@ namespace :rails_rbi do
       begin
         formatter = SorbetRails::ModelRbiFormatter.new(model_class, available_class_names)
         [model_class.name, formatter.generate_rbi]
-      rescue StandardError => ex
+      rescue StandardError, NotImplementedError => ex
         puts "---"
         puts "Error when handling model #{model_class.name}: #{ex}"
         nil

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.5.8.1"
+  s.version       = "0.5.9"
   s.date          = %q{2019-04-18}
   s.summary       = %q{Set of tools to make Sorbet work with Rails seamlessly.}
   s.authors       = ["Chan Zuckerberg Initiative"]
@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
     `git ls-files -z`.split("\x0").select { |f| f.match(%r{^(test|spec|features)/}) }
   end
 
-  s.add_dependency 'parlour', '~> 0.8.0'
+  s.add_dependency 'parlour', '~> 1.0'
 
   # Development
   s.add_development_dependency 'rspec', '~> 3.8', '>= 3.8'