sorbet-rails 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3878883de9a212a28dbbd5f11aa6a1d6a0f58fd4840b26d958942b90b4bf802d
-  data.tar.gz: 3367e7a6ad7519c10c3a160372b505a605ccefd2e4437ae86b275b1b01c5df4c
+  metadata.gz: 6b43d7a27b379e20892375b314afd08e4897ad6e0b20167b1a366de3121d0470
+  data.tar.gz: f6817dea5503132acc030da42ce68149675192c98536b8c795d8705a0e42649d
 SHA512:
-  metadata.gz: 76b1d238246210fe8d3735dbf216c0cb89529550b9364204571d9d4aed878f42c3a998bb48eaeaa8eb156c2cca758cf4535fc95ae445ef2c6c192b58dbc3bdd0
-  data.tar.gz: 97979cd91324b862e3ae0c0f9c53bd443613b1dfa0b8701680c0055d382057a6cdf45110183a43b19714b93b4d2ddedd9f7ba42ee4192f3d9c6597c8b4ddf45f
+  metadata.gz: 15251522124262b9c7aab57915d2cc5bc18e0807ccf27e2ea47e0d17173473a5d8a5a09ac4ea41e899de47a7972456ae060ef981e811e5f22095309c79d89b27
+  data.tar.gz: 7178e09505141a408617d2513f9da84ee8868edf5c808c3bca0ba293dbec4bb3cbbbe1362ad8b0af2f75f20862de4f95b67ddf6b1365a6d10111598bd9779b75

data/.gitignore

@@ -94,3 +94,4 @@ build-iPhoneSimulator/
 *.swk
 
 lib/sorbet/rbi/hidden-definitions/errors.txt
+.vscode

data/CONTRIBUTING.md

@@ -124,8 +124,8 @@ copied into each app with `cp`.
 The `rails-template.rb` file uses the
 [Rails Application Template](https://guides.rubyonrails.org/rails_application_templates.html)
 functionality included in Rails. You can then regenerate each Rails app from
-the same file using `bundle _1.17.3_ exec rake update_spec:v4.2`, `bundle exec rake update_spec:v5.0`,
-`bundle exec rake update_spec:v5.1`, etc. (or just `bundle exec rake update_spec:v5_plus`,
+the same file using `bundle _1.17.3_ exec rake update_spec:v4_2`, `bundle exec rake update_spec:v5_0`,
+`bundle exec rake update_spec:v5_1`, etc. (or just `bundle exec rake update_spec:v5_plus`,
 though this excludes regenerating 4.2 because 4.2 blocks usage of Bundler 2.x).
 
 #### Expected Output

data/README.md

@@ -30,6 +30,7 @@ gem 'sorbet-rails'
 ❯ rake rails_rbi:routes
 ❯ rake rails_rbi:models
 ❯ rake rails_rbi:helpers
+❯ rake rails_rbi:mailers
 
 # or run them all at once
 ❯ rake rails_rbi:all
@@ -76,12 +77,32 @@ It is possible to add custom RBI generation logic for your custom module or gems
 
 ### Helpers
 
-This Rake task generates a `helpers.rbi` file that includes a basic module definition which includes the `Kernel` module, to allow for some basic Ruby methods to be used in helpers without Sorbet complaining.
+This Rake task generates a `helpers.rbi` file that includes a basic module definition which includes the `Kernel` module and `ActionView::Helpers`, to allow for some basic Ruby methods to be used in helpers without Sorbet complaining.
 
 ```sh
 ❯ rake rails_rbi:helpers
 ```
 
+If you have additional modules that are included in all your helpers and you want `helpers.rbi` to reflect this, you can configure it:
+
+```ruby
+# -- config/initializers/sorbet_rails.rb
+SorbetRails.configure do |config|
+  config.extra_helper_includes = ['ApplicationHelper', 'Devise::Controllers::Helpers']
+end
+
+### Mailers
+
+This Rake task generates RBI files for all mailer classes in the Rails application (all descendants of `ActionMailer::Base`)
+```sh
+❯ rake rails_rbi:mailers
+```
+
+Since mailing action methods is based on instance methods defined in a mailer class, the signature of a mailing action method will be dependent on the signature the instance method has
+- If there is a (sorbet) sig written for the instance method, it generates a matching sig for the mailing action method
+- 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.
+
 ## Tips & Tricks
 
 ### Overriding generated signatures

data/lib/sorbet-rails/actionmailer.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+class ActionMailer::Base
+  extend T::Sig
+
+  sig { returns(T::Array[Symbol]) }
+  def self.action_methods; end
+end

data/lib/sorbet-rails/activerecord.rbi

@@ -20,6 +20,9 @@ class ActiveRecord::Base < Object
 
   sig { returns(T::Boolean) }
   def self.abstract_class?; end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def self.attachment_reflections; end
 end
 
 class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter;

data/lib/sorbet-rails/config.rb

@@ -34,6 +34,9 @@ module SorbetRails
     sig { returns(T::Array[Symbol]) }
     attr_accessor :enabled_model_plugins
 
+    sig { returns(T::Array[String]) }
+    attr_accessor :extra_helper_includes
+
     sig { void }
     def initialize
       @enabled_gem_plugins = []
@@ -48,6 +51,8 @@ module SorbetRails
         :custom_finder_methods,
         :enumerable_collections,
       ]
+      @enabled_model_plugins << :active_storage_methods if defined?(T.unsafe(ActiveStorage))
+      @extra_helper_includes = []
     end
 
     sig { returns(T::Array[Symbol]) }

data/lib/sorbet-rails/helper_rbi_formatter.rb

@@ -25,6 +25,9 @@ class SorbetRails::HelperRbiFormatter
       @parlour.root.create_module(helper.to_s) do |mod|
         mod.create_include('Kernel')
         mod.create_include('ActionView::Helpers')
+        ::SorbetRails.config.extra_helper_includes.each do |extra_helper|
+          mod.create_include(extra_helper) unless extra_helper == helper.to_s
+        end
       end
     end
 

data/lib/sorbet-rails/mailer_rbi_formatter.rb

@@ -0,0 +1,38 @@
+# typed: strict
+require('parlour')
+require('sorbet-rails/sorbet_utils.rb')
+
+class SorbetRails::MailerRbiFormatter
+  extend T::Sig
+
+  sig { params(mailer_class: T.class_of(ActionMailer::Base)).void }
+  def initialize(mailer_class)
+    @mailer_class = T.let(mailer_class, T.class_of(ActionMailer::Base))
+    @parlour = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
+  end
+
+  sig {returns(String)}
+  def generate_rbi
+    puts "-- Generate sigs for mailer #{@mailer_class.name} --"
+
+    @parlour.root.add_comments([
+      'This is an autogenerated file for Rails helpers.',
+      'Please rerun rake rails_rbi:mailers to regenerate.'
+    ])
+
+    @parlour.root.create_class(@mailer_class.name) do |mailer_rbi|
+      @mailer_class.action_methods.to_a.sort.each do |mailer_method|
+        method_def = @mailer_class.instance_method(mailer_method)
+        parameters = SorbetRails::SorbetUtils.parameters_from_method_def(method_def)
+        mailer_rbi.create_method(
+          mailer_method,
+          parameters: parameters,
+          return_type: 'ActionMailer::MessageDelivery',
+          class_method: true,
+        )
+      end
+    end
+
+    @parlour.rbi + "\n"
+  end
+end

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

@@ -1,7 +1,7 @@
 # typed: true
 require ('sorbet-rails/model_plugins/base')
 class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::Base
-  sig {params(model_class: T.class_of(ActiveRecord::Base), available_classes: T::Set[String]).void}
+  sig { params(model_class: T.class_of(ActiveRecord::Base), available_classes: T::Set[String]).void }
   def initialize(model_class, available_classes)
     super
     @columns_hash = @model_class.table_exists? ? @model_class.columns_hash : {}
@@ -25,16 +25,29 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
     end
   end
 
+  sig do
+    params(
+      assoc_module_rbi: T.untyped,
+      assoc_name: T.untyped,
+      reflection: T.untyped
+    ).void
+  end
   def populate_single_assoc_getter_setter(assoc_module_rbi, assoc_name, reflection)
     # TODO allow people to specify the possible values of polymorphic associations
     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
-      # this field is required & use a stronger type
       column_def = @columns_hash[reflection.foreign_key.to_s]
-      if column_def
-        assoc_type = assoc_class if !column_def.null
+      if ENV["RAILS_VERSION"] == "4.2"
+        # Before Rails 5, belongs_to relations were nilable by default
+        # if this is a belongs_to connection, we may be able to detect whether
+        # this field is required & use a stronger type
+        if column_def
+          assoc_type = assoc_class if !column_def.null
+        end
+      else
+        # In Rails 5 and later, belongs_to are required unless specified to be optional
+        assoc_type = assoc_class if !reflection.options[:optional]
       end
     end
 
@@ -51,6 +64,13 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
     )
   end
 
+  sig do
+    params(
+      assoc_module_rbi: T.untyped,
+      assoc_name: T.untyped,
+      reflection: T.untyped
+    ).void
+  end
   def populate_collection_assoc_getter_setter(assoc_module_rbi, assoc_name, reflection)
     # TODO allow people to specify the possible values of polymorphic associations
     assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : "::#{reflection.klass.name}"
@@ -88,4 +108,4 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
       polymorphic_assoc?(reflection.source_reflection) :
       reflection.polymorphic?
   end
-end
+end

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

@@ -55,7 +55,7 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     end
   end
 
-  sig {params(column_def: T.untyped).returns(T.any(String, Class))}
+  sig { params(column_def: T.untyped).returns(T.any(String, Class)) }
   def type_for_column_def(column_def)
     cast_type = ActiveRecord::Base.connection.respond_to?(:lookup_cast_type_from_column) ?
       ActiveRecord::Base.connection.lookup_cast_type_from_column(column_def) :
@@ -69,13 +69,12 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     column_def.null ? "T.nilable(#{strict_type})" : strict_type
   end
 
-  sig {
+  sig do
     params(
       # in v4.2, datetime can be TimeZoneConverter
       klass: T.any(Object, ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
-    ).
-    returns(T.any(String, Class))
-  }
+    ).returns(T.any(String, Class))
+  end
   def active_record_type_to_sorbet_type(klass)
     case klass
     when ActiveRecord::Type::Boolean

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

@@ -1,5 +1,6 @@
 # typed: strict
 require ('sorbet-rails/model_plugins/base')
+require("sorbet-rails/utils")
 class SorbetRails::ModelPlugins::ActiveRecordEnum < SorbetRails::ModelPlugins::Base
 
   sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
@@ -13,20 +14,53 @@ class SorbetRails::ModelPlugins::ActiveRecordEnum < SorbetRails::ModelPlugins::B
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(enum_module_name)
 
+    enum_calls = ActiveRecordOverrides.instance.enum_calls[self.model_class_name]
+
     # TODO: add any method for signature verification?
     model_class.defined_enums.sort.each do |enum_name, enum_hash|
+      value_type = enum_hash.values.map { |v| v.is_a?(Integer) ? 'Integer' : v.class.name }.uniq
+
+      return_type = if value_type.length == 1
+        "T::Hash[T.any(String, Symbol), #{value_type.first}]"
+      else
+        "T::Hash[T.any(String, Symbol), T.any(#{value_type.join(", ")})]"
+      end
+
       model_class_rbi.create_method(
         enum_name.pluralize,
-        return_type: "T::Hash[T.any(String, Symbol), Integer]",
+        return_type: return_type,
         class_method: true,
       )
+
+      enum_call = enum_calls.find {|call| call.has_key?(enum_name.to_sym)}
+
+      enum_prefix = enum_call[:_prefix]
+      prefix =
+        if enum_prefix == true
+          "#{enum_name}_"
+        elsif enum_prefix
+          "#{enum_prefix}_"
+        else
+          ''
+        end
+      enum_suffix = enum_call[:_suffix]
+      suffix =
+        if enum_suffix == true
+          "_#{enum_name}"
+        elsif enum_suffix
+          "_#{enum_suffix}"
+        else
+          ''
+        end
+
       enum_hash.keys.each do |enum_val|
+        next unless SorbetRails::Utils.valid_method_name?(enum_val.to_s)
         enum_module_rbi.create_method(
-          "#{enum_val}?",
+          "#{prefix}#{enum_val}#{suffix}?",
           return_type: "T::Boolean",
         )
         enum_module_rbi.create_method(
-          "#{enum_val}!",
+          "#{prefix}#{enum_val}#{suffix}!",
           return_type: nil, # void
         )
       end

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

@@ -1,5 +1,6 @@
 # typed: strict
 require ('sorbet-rails/model_plugins/base')
+require("sorbet-rails/utils")
 class SorbetRails::ModelPlugins::ActiveRecordNamedScope < SorbetRails::ModelPlugins::Base
 
   sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
@@ -7,6 +8,7 @@ class SorbetRails::ModelPlugins::ActiveRecordNamedScope < SorbetRails::ModelPlug
     model_class_rbi = root.create_class(self.model_class_name)
 
     @model_class.methods.sort.each do |method_name|
+      next unless SorbetRails::Utils.valid_method_name?(method_name.to_s)
       method_obj = @model_class.method(method_name)
       next unless method_obj.present? && method_obj.source_location.present?
       # we detect sscopes defined in a model by 2 criteria:

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

@@ -0,0 +1,27 @@
+# typed: false
+
+require 'singleton'
+
+class ActiveRecordOverrides
+  include Singleton
+
+  attr_reader :enum_calls
+
+  def initialize
+    @enum_calls = {}
+  end
+
+  def store_enum_call(class_name, kwargs)
+    @enum_calls[class_name] ||= []
+    @enum_calls[class_name] << kwargs
+  end
+end
+
+module ::ActiveRecord::Enum
+  alias old_enum enum
+
+  def enum(*args, **kwargs)
+    ActiveRecordOverrides.instance.store_enum_call(T.unsafe(self).name, kwargs)
+    old_enum(*args, **kwargs)
+  end
+end

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

@@ -0,0 +1,60 @@
+# typed: true
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveStorageMethods < SorbetRails::ModelPlugins::Base
+  sig { params(model_class: T.class_of(ActiveRecord::Base), available_classes: T::Set[String]).void }
+  def initialize(model_class, available_classes)
+    super
+  end
+
+  sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    # Check that ActiveStorage the attachment_reflections method exists
+    # It was added in 6.0, so it isn't available for 5.2.
+    return unless defined?(@model_class.attachment_reflections) && @model_class.attachment_reflections.length > 0
+
+    assoc_module_name = self.model_module_name("GeneratedAssociationMethods")
+    assoc_module_rbi = root.create_module(assoc_module_name)
+
+    attachment_reflections = @model_class.attachment_reflections.transform_values { |attachment| attachment.class }
+
+    attachment_reflections.each do |assoc_name, attachment_type|
+      if attachment_type.to_s == 'ActiveStorage::Reflection::HasOneAttachedReflection'
+        create_has_one_methods(assoc_name, assoc_module_rbi)
+      elsif attachment_type.to_s == 'ActiveStorage::Reflection::HasManyAttachedReflection'
+        create_has_many_methods(assoc_name, assoc_module_rbi)
+      end
+    end
+  end
+
+  sig { params(assoc_name: String, mod: Parlour::RbiGenerator::Namespace).void }
+  def create_has_one_methods(assoc_name, mod)
+    mod.create_method(
+      assoc_name,
+      return_type: 'T.nilable(ActiveStorage::Attached::One)'
+    )
+
+    mod.create_method(
+      "#{assoc_name}=",
+      parameters: [
+        Parameter.new('attachable', type: 'T.untyped')
+      ],
+      return_type: 'T.untyped'
+    )
+  end
+
+  sig { params(assoc_name: String, mod: Parlour::RbiGenerator::Namespace).void }
+  def create_has_many_methods(assoc_name, mod)
+    mod.create_method(
+      assoc_name,
+      return_type: 'T.nilable(ActiveStorage::Attached::Many)'
+    )
+
+    mod.create_method(
+      "#{assoc_name}=",
+      parameters: [
+        Parameter.new('*attachables', type: 'T.untyped')
+      ],
+      return_type: 'T.untyped'
+    )
+  end
+end

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

@@ -9,6 +9,8 @@ require('sorbet-rails/model_plugins/active_record_assoc')
 require('sorbet-rails/model_plugins/active_record_finder_methods')
 require('sorbet-rails/model_plugins/custom_finder_methods')
 require('sorbet-rails/model_plugins/enumerable_collections')
+require('sorbet-rails/model_plugins/active_record_overrides')
+require('sorbet-rails/model_plugins/active_storage_methods')
 
 module SorbetRails::ModelPlugins
   extend T::Sig
@@ -57,6 +59,8 @@ module SorbetRails::ModelPlugins
       CustomFinderMethods
     when :enumerable_collections
       EnumerableCollections
+    when :active_storage_methods
+      ActiveStorageMethods
     when :kaminari
       require('sorbet-rails/gem_plugins/kaminari_plugin')
       KaminariPlugin

data/lib/sorbet-rails/sorbet_utils.rb

@@ -0,0 +1,68 @@
+# typed: false
+
+require('parlour')
+require('sorbet-runtime')
+
+module SorbetRails::SorbetUtils
+  extend T::Sig
+
+  sig { params(method_def: UnboundMethod).returns(T::Array[Parlour::RbiGenerator::Parameter]) }
+  def self.parameters_from_method_def(method_def)
+    signature = T::Private::Methods.signature_for_method(method_def)
+
+    parameters_with_type = signature.nil? ?
+      method_def.parameters.map { |p| p + ['T.untyped'] } : # append untyped to each
+      get_ordered_parameters_with_type(signature)
+
+    parameters_with_type.map do |param_def|
+      param_name = param_def[1]
+      prefix =
+        case param_def[0]
+        when :rest; '*'
+        when :keyrest; '**'
+        when :block; '&'
+        # being comprehensive
+        when :req, :opt; ''
+        when :key, :keyreq; ''
+        else ''
+        end
+
+      param_type = param_def[2].to_s
+      if param_def[0] == :block
+        # special case `.void` in a proc
+        # see https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/types/proc.rb#L10
+        param_type = param_type.gsub('returns(<VOID>)', 'void')
+      end
+
+      ::Parlour::RbiGenerator::Parameter.new("#{prefix}#{param_name}", type: param_type)
+    end
+  end
+
+  sig {
+    params(signature: T::Private::Methods::Signature).
+    returns(T::Array[[Symbol, Symbol, T::Types::Base]])
+  }
+  def self.get_ordered_parameters_with_type(signature)
+    # extract original method param from signature
+    # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/private/methods/signature.rb#L5-L8
+    params = []
+    signature.arg_types.each do |arg_type|
+      # could be :opt, but doesn't matter
+      params << [:req, arg_type[0], arg_type[1]]
+    end
+    signature.req_kwarg_names.each do |kwarg_name|
+      # could be :key, but doesn't matter
+      params << [:keyreq, kwarg_name, signature.kwarg_types[kwarg_name]]
+    end
+    if signature.has_rest
+      params << [:rest, signature.rest_name, signature.rest_type]
+    end
+    if signature.has_keyrest
+      params << [:keyrest, signature.keyrest_name, signature.keyrest_type]
+    end
+    if !signature.block_name.nil?
+      params << [:block, signature.block_name, signature.block_type]
+    end
+    params
+  end
+end