sorbet-rails 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7e0b556a5c7db33a8fa24c494fa70265802a360eb842545b6124d54ade20e47
-  data.tar.gz: 5f26a6773d2769e1dfc523f4202b179ded8deaebb65e05ade61291f03153f164
+  metadata.gz: 573cda715fb4ceb9881c61dce1f346499a60202ac181548727d7519f8f1b24fe
+  data.tar.gz: ba219d4d0ec79076e4a93cf2b6c0eb40272489fb4b71d42eea881c6c7c124b6e
 SHA512:
-  metadata.gz: cc61969e6954e727113e9e74ba48925c15ee07b940fbe5d3a711d62270f90ba06ce9c36373420a3cf02c9a52bda3256ef63d9bea6bf2bcd580dfa592faba068c
-  data.tar.gz: 8c0bb6e747de6ac12c77b326b01d941f3f24fdd6444fca05d573ff26c20a2d0d679bbcd713adb37f66919781446137d3f0fdd21bb39b36241c6e1d6a98ac1de6
+  metadata.gz: e6d81c40b7c86667834b5063637e9ed29204fda6494aaeccd59781ae481849d7e90b4f5edf678b6727197e6f194c3b06bc87c276e7801013343f2e698c904e3e
+  data.tar.gz: 11b034a0b6691ae3d9baf8a2c285b3277c99aa25d280eba8bf12bc78b5a443a4d5d502e814edf1eb576c1bbc108301cfcc0b240cff354a03163497e109ca403c

data/.travis.yml

@@ -24,6 +24,8 @@ matrix:
     env: RAILS_VERSION=6.0
   allow_failures:
   - rvm: ruby-head
+  - rvm: 2.7
+    env: RAILS_VERSION=6.0
 before_install:
 - gem install bundler -v 2.0.1 --no-doc
 - gem install bundler -v 1.17.3 --no-doc

data/README.md

@@ -73,7 +73,7 @@ It is possible to add custom RBI generation logic for your custom module or gems
 We also add following methods to make type-checking more easily:
 - [`find_n`, `first_n`, `last_n`](https://github.com/chanzuckerberg/sorbet-rails#find-first-and-last)
 - [`pluck_to_tstruct`](#pluck_to_tstruct-instead-of-pluck)
-- [`typed_enum`](#enums)
+- [`typed_enum`](#typed_enum-instead-of-enum)
 - [`Model::RelationType`](#relationtype-alias)
 
 #### `pluck_to_tstruct` instead of `pluck`
@@ -96,7 +96,7 @@ Wizard.all.pluck_to_tstruct(TA[WizardStruct].new)  # T::Array[WizardStruct]
 
 This method is based on [pluck_to_hash](https://github.com/girishso/pluck_to_hash) gem.
 
-#### Enums
+#### `typed_enum` instead of `enum`
 
 If you use [Rails `enum`](https://guides.rubyonrails.org/active_record_querying.html#enums), `sorbet-rails` will generate a corresponding `T::Enum`. It will also include getters, setters, and scope methods in the rbi file it generates.
 
@@ -203,7 +203,7 @@ end
 If it fails to coerce the params into the right type, an `ActionController::BadRequest` exception will be raised with the coercion context for debugging.
 
 Note: The API `TypedParams[...].new.extract!` may seem verbose, but necessary to support this feature. Ideally, the API can be simply `TypedParams.extract!(...)`. However, `sorbet` [doesn't support](http://github.com/sorbet/sorbet/issues/62) defining a method that accept a type and return an instance of the type. If this feature is supported by `sorbet` in the future, it will be easy to codemod to be `TypedParams.extract(...)!` part from your code.
-Note: [`require_typed` and `fetch_typed`](https://github.com/chanzuckerberg/sorbet-rails/blob/v0.5.9.1/README.md) are deprecated in favor of `TypedParams`.
+Note: [`require_typed` and `fetch_typed`](https://github.com/chanzuckerberg/sorbet-rails/blob/v0.5.9.1/README.md) are deprecated in favor of `TypedParams`. They will be removed in v0.7.
 
 ### Routes
 

data/lib/bundled_rbi/typed_enum.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+module ActiveRecord::Enum
+
+  sig { params(definitions: T::Hash[Symbol, T.untyped]).void }
+  def typed_enum(definitions); end
+
+end

data/lib/sorbet-rails.rb

@@ -4,8 +4,6 @@ module SorbetRails
     require 'sorbet-rails/railtie'
     require 'sorbet-rails/model_rbi_formatter'
     require 'sorbet-rails/type_assert/type_assert'
-    require 'sorbet-rails/custom_types/integer_string'
-    require 'sorbet-rails/custom_types/boolean_string'
     require 'sorbet-rails/typed_params'
   end
 end

data/lib/sorbet-rails/active_record_rbi_formatter.rb

@@ -0,0 +1,301 @@
+# typed: strict
+require('parlour')
+
+class SorbetRails::ActiveRecordRbiFormatter
+  extend T::Sig
+
+  Parameter = ::Parlour::RbiGenerator::Parameter
+
+  sig {returns(String)}
+  def generate_active_record_base_rbi
+    puts "-- Generate sigs for ActiveRecord::Base --"
+
+    parlour = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
+
+    parlour.root.add_comments([
+      'This is an autogenerated file for Rails\' ActiveRecord.',
+      'Please rerun bundle exec rake rails_rbi:active_record to regenerate.'
+    ])
+
+    parlour.root.create_class('ActiveRecord::Base') do |class_rbi|
+      create_elem_specific_query_methods(class_rbi, type: 'T.attached_class', class_method: true)
+      create_general_query_methods(class_rbi, class_method: true)
+    end
+
+    parlour.rbi
+  end
+
+  sig {returns(String)}
+  def generate_active_record_relation_rbi
+    puts "-- Generate sigs for ActiveRecord::Relation --"
+
+    parlour = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
+
+    parlour.root.add_comments([
+      'This is an autogenerated file for Rails\' ActiveRecord.',
+      'Please rerun bundle exec rake rails_rbi:active_record to regenerate.'
+    ])
+
+    parlour.root.create_class('ActiveRecord::Relation') do |class_rbi|
+      class_rbi.create_include("Enumerable")
+      class_rbi.create_constant(
+        "Elem",
+        value: "type_member(fixed: T.untyped)",
+      )
+
+      create_elem_specific_query_methods(class_rbi, type: 'Elem', class_method: false)
+      create_general_query_methods(class_rbi, class_method: false)
+
+      # Many methods that exist on the relation classes also exist on the model class
+      # by delegating to `:all` (e.g. `Model.any?` is really `Model.all.any?`). These
+      # methods (e.g. each, empty?) only exist on the relation classes.
+      class_rbi.create_method(
+        "each",
+        parameters: [
+          Parameter.new("&block", type: "T.proc.params(e: Elem).void")
+        ],
+        return_type: "T::Array[Elem]",
+        implementation: true,
+      )
+      class_rbi.create_method(
+        "flatten",
+        parameters: [ Parameter.new("level", type: "T.nilable(Integer)") ],
+        return_type: "T::Array[Elem]",
+      )
+      class_rbi.create_method("to_a", return_type: "T::Array[Elem]")
+      class_rbi.create_method(
+        "map",
+        type_parameters: [:U],
+        parameters: [ Parameter.new("&blk", type: "T.proc.params(arg0: Elem).returns(T.type_parameter(:U))") ],
+        return_type: "T::Array[T.type_parameter(:U)]",
+      )
+      class_rbi.create_method('empty?', return_type: "T::Boolean")
+    end
+
+    parlour.root.create_class("ActiveRecord::AssociationRelation", superclass: "ActiveRecord::Relation") do |class_rbi|
+      class_rbi.create_constant(
+        "Elem",
+        value: "type_member(fixed: T.untyped)",
+      )
+
+      # Ideally we shouldn't need to define these since this class inherits from
+      # ActiveRecord::Relation but the activerecord.rbi that sorbet generates
+      # defines some methods which sorbet finds instead of the methods inherited
+      # by ActiveRecord::Relation. Some of these methods have different arity or
+      # parameters than the ones defined by `create_elem_specific_query_methods` so
+      # we need to match the signatures in that conflicting rbi.
+      build_methods = %w(new build create create!)
+      # This needs to match the generated method signature in activerecord.rbi and
+      # in Rails 5.0 and 5.1 the param is a splat.
+      if Rails.version =~ /^5\./
+        build_param = Parameter.new("*args", type: "T.untyped")
+      else
+        build_param = Parameter.new("attributes", type: "T.untyped", default: 'nil')
+      end
+      build_methods.each do |build_method|
+        class_rbi.create_method(
+          build_method,
+          parameters: [
+            build_param,
+            Parameter.new(
+              "&block",
+              type: "T.nilable(T.proc.params(object: Elem).void)",
+            ),
+          ],
+          return_type: "Elem",
+        )
+      end
+    end
+
+    parlour.root.create_class("ActiveRecord::Associations::CollectionProxy", superclass: "ActiveRecord::Relation") do |class_rbi|
+      class_rbi.create_constant(
+        "Elem",
+        value: "type_member(fixed: T.untyped)",
+      )
+
+      # This _should_ work which would let us remove it from the enumerable_collections
+      # plugin but sorbet has a bug with T.any and generics.
+      # See: https://github.com/sorbet/sorbet/issues/2938
+      # push_methods = %w(<< append push concat)
+      # push_methods.each do |push_method|
+      #   class_rbi.create_method(
+      #     push_method,
+      #     parameters: [
+      #       Parameter.new("*records", type: "T.any(Elem, T::Array[Elem])"),
+      #     ],
+      #     return_type: "T.self_type",
+      #   )
+      # end
+
+      # Ideally we shouldn't need to define these since this class inherits from
+      # ActiveRecord::Relation but the activerecord.rbi that sorbet generates
+      # defines some methods which sorbet finds instead of the methods inherited
+      # by ActiveRecord::Relation. Some of these methods have different arity or
+      # parameters than the ones defined by `create_elem_specific_query_methods` so
+      # we need to match the signatures in that conflicting rbi.
+      build_methods = %w(new build create create!)
+      build_methods.each do |build_method|
+        class_rbi.create_method(
+          build_method,
+          parameters: [
+            Parameter.new("attributes", type: "T.untyped", default: 'nil'),
+            Parameter.new(
+              "&block",
+              type: "T.nilable(T.proc.params(object: Elem).void)",
+            ),
+          ],
+          return_type: "Elem",
+        )
+      end
+
+      class_rbi.create_method(
+        "find",
+        parameters: [Parameter.new("*args", type: "T.untyped")],
+        return_type: "Elem",
+      )
+
+      if Rails.version =~ /^5\.0/
+        item_methods = %w(first second third third_to_last second_to_last last)
+        item_methods.each do |item_method|
+          class_rbi.create_method(
+            item_method,
+            parameters: [Parameter.new("*args", type: "T.untyped")],
+            return_type: "T.nilable(Elem)",
+          )
+        end
+
+        boolean_methods = %w(any? many?)
+        boolean_methods.each do |boolean_method|
+          class_rbi.create_method(boolean_method, return_type: "T::Boolean")
+        end
+      else
+        class_rbi.create_method(
+          "last",
+          parameters: [Parameter.new("limit", type: "T.untyped", default: "nil")],
+          return_type: "T.nilable(Elem)",
+        )
+      end
+
+      if Rails.version =~ /^5\.(0|1)/
+        class_rbi.create_method("to_a", return_type: "T::Array[Elem]")
+      end
+
+      class_rbi.create_method('empty?', return_type: "T::Boolean")
+    end
+
+    parlour.rbi
+  end
+
+  sig {
+    params(
+      class_rbi: Parlour::RbiGenerator::Namespace,
+      type: String,
+      class_method: T::Boolean,
+    ).void
+  }
+  def create_elem_specific_query_methods(class_rbi, type:, class_method:)
+    finder_methods = %w(find find_by find_by!)
+    finder_methods.each do |finder_method|
+      class_rbi.create_method(
+        finder_method,
+        parameters: [ Parameter.new("*args", type: "T.untyped") ],
+        return_type: (finder_method == 'find' || finder_method.ends_with?('!')) ? type : "T.nilable(#{type})",
+        class_method: class_method,
+      )
+    end
+
+    first_or_something_by_methods = %w(find_or_initialize_by find_or_create_by find_or_create_by!)
+    first_or_something_by_methods.each do |first_or_something_by_method|
+      class_rbi.create_method(
+        first_or_something_by_method,
+        parameters: [
+          Parameter.new("attributes", type: "T.untyped"),
+          Parameter.new(
+            "&block",
+            type: "T.nilable(T.proc.params(object: #{type}).void)",
+          ),
+        ],
+        return_type: type,
+        class_method: class_method
+      )
+    end
+
+    item_methods = %w(first first! second second! third third! third_to_last third_to_last! second_to_last second_to_last! last last!)
+    item_methods.each do |item_method|
+      class_rbi.create_method(
+        item_method,
+        return_type: item_method.ends_with?('!') ? type : "T.nilable(#{type})",
+        class_method: class_method,
+      )
+    end
+
+    build_methods = %w(create create! new build first_or_create first_or_create! first_or_initialize)
+    build_methods.each do |build_method|
+      # `build` method doesn't exist on the model, only on the relations
+      next if build_method == 'build' && class_method
+
+      # This needs to match the generated method signature in activerecord.rbi and
+      # in Rails 5.0 and 5.1 the param is a splat.
+      if Rails.version =~ /^5\.(0|1)/ && %w(new build create create!).include?(build_method)
+        param = Parameter.new("*args", type: "T.untyped")
+      else
+        param = Parameter.new("attributes", type: "T.untyped", default: 'nil')
+      end
+
+      class_rbi.create_method(
+        build_method,
+        parameters: [
+          param,
+          Parameter.new(
+            "&block",
+            type: "T.nilable(T.proc.params(object: #{type}).void)",
+          ),
+        ],
+        return_type: type,
+        class_method: class_method,
+      )
+    end
+
+    batch_methods = %w(find_each find_in_batches)
+    batch_methods.each do |batch_method|
+      inner_type = batch_method == 'find_each' ? type : "T::Array[#{type}]"
+
+      class_rbi.create_method(
+        batch_method,
+        parameters: [
+          Parameter.new("start:", type: "T.nilable(Integer)", default: "nil"),
+          Parameter.new("finish:", type: "T.nilable(Integer)", default: "nil"),
+          Parameter.new("batch_size:", type: "T.nilable(Integer)", default: "1000"),
+          Parameter.new("error_on_ignore:", type: "T.nilable(T::Boolean)", default: "nil"),
+          Parameter.new("&block", type: "T.nilable(T.proc.params(e: #{inner_type}).void)"),
+        ],
+        return_type: "T::Enumerator[#{inner_type}]",
+        class_method: class_method,
+      )
+    end
+  end
+
+  sig {
+    params(
+      class_rbi: Parlour::RbiGenerator::Namespace,
+      class_method: T::Boolean,
+    ).void
+  }
+  def create_general_query_methods(class_rbi, class_method:)
+    class_rbi.create_method(
+      "exists?",
+      parameters: [ Parameter.new("conditions", type: "T.untyped", default: "nil") ],
+      return_type: "T::Boolean",
+      class_method: class_method,
+    )
+
+    boolean_methods = %w(any? many? none? one?)
+    boolean_methods.each do |boolean_method|
+      class_rbi.create_method(
+        boolean_method,
+        return_type: "T::Boolean",
+        class_method: class_method,
+      )
+    end
+  end
+end

data/lib/sorbet-rails/config.rb

@@ -47,7 +47,6 @@ module SorbetRails
         :active_relation_where_not,
         :active_record_attribute,
         :active_record_assoc,
-        :active_record_finder_methods,
         :custom_finder_methods,
         :enumerable_collections,
       ]

data/lib/sorbet-rails/dependent_gem_rbis/activerecord.rbi

@@ -28,3 +28,14 @@ end
 class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter;
   def klass; end
 end
+
+class ActiveModel::Validations::PresenceValidator
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  attr_reader :options
+end
+
+module ActiveModel::Validations
+  module ClassMethods
+    def validators_on(*attributes); end
+  end
+end

data/lib/sorbet-rails/deprecation.rb

@@ -0,0 +1,5 @@
+require 'active_support/deprecation'
+
+module SorbetRails
+  TypeAssertDeprecation = ActiveSupport::Deprecation.new('0.7', 'SorbetRails')
+end

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

@@ -7,7 +7,6 @@ class ActiveFlagPlugin < SorbetRails::ModelPlugins::Base
 
     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)

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

@@ -8,7 +8,6 @@ class PaperclipPlugin < SorbetRails::ModelPlugins::Base
 
     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)

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

@@ -13,7 +13,6 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
 
     assoc_module_name = self.model_module_name("GeneratedAssociationMethods")
     assoc_module_rbi = root.create_module(assoc_module_name)
-    assoc_module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(assoc_module_name)
@@ -35,7 +34,7 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
   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 = belongs_to_and_required?(reflection) ? assoc_class : "T.nilable(#{assoc_class})"
+    assoc_type = (belongs_to_and_required?(reflection) || has_one_and_required?(reflection)) ? assoc_class : "T.nilable(#{assoc_class})"
 
     assoc_module_rbi.create_method(
       assoc_name.to_s,
@@ -56,6 +55,9 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
     # optional (via `optional` or `!required` or `!belongs_to_required_by_default`)
     return false if !reflection.belongs_to?
 
+    column_def = @columns_hash[reflection.foreign_key.to_s]
+    db_required_config = column_def.present? && !column_def.null
+
     rails_required_config =
       if reflection.options.key?(:required)
         !!reflection.options[:required]
@@ -65,22 +67,34 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
         !!reflection.active_record.belongs_to_required_by_default
       end
 
-    column_def = @columns_hash[reflection.foreign_key.to_s]
-    db_required_config = column_def.present? && !column_def.null
+    # We check for validations on both the column name (e.g. wizard_id) and
+    # association name (e.g. wizard).
+    rails_required_config ||= [column_def&.name, reflection.name].compact.any? { |n| attribute_has_unconditional_presence_validation?(n) }
 
     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.\n 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 "Note: belongs_to association #{reflection.name} is specified as not-null at the
-        DB level but **optional** at the application level.\n Add a constraint at the app level
-        (using `optional: false`) as a validation hint to Rails.".squish!
+      if habtm_class?
+        puts "Note: belongs_to association #{reflection.name} is specified as not-null at the
+          DB level but will always be **optional** at the application level since it's part of a
+          has_and_belongs_to_many association.\n To resolve move to a 'has_many through:' association.".squish!
+      else
+        puts "Note: belongs_to association #{reflection.name} is specified as not-null at the
+          DB level but **optional** at the application level.\n Add a constraint at the app level
+          (using `optional: false`) as a validation hint to Rails.".squish!
+      end
     end
 
     rails_required_config || db_required_config
   end
 
+  sig { params(reflection: T.untyped).returns(T::Boolean) }
+  private def has_one_and_required?(reflection)
+    !!(reflection.has_one? && attribute_has_unconditional_presence_validation?(reflection.name))
+  end
+
   sig do
     params(
       assoc_module_rbi: T.untyped,
@@ -99,6 +113,12 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
       assoc_name.to_s,
       return_type: relation_class,
     )
+    unless assoc_should_be_untyped?(reflection)
+      assoc_module_rbi.create_method(
+        "#{assoc_name.singularize}_ids",
+        return_type: "T::Array[Integer]",
+      )
+    end
     assoc_module_rbi.create_method(
       "#{assoc_name}=",
       parameters: [
@@ -110,7 +130,15 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
 
   sig { params(reflection: T.untyped).returns(T.nilable(T::Boolean)) }
   def assoc_should_be_untyped?(reflection)
-    polymorphic_assoc?(reflection) || !@available_classes.include?(reflection.klass.name)
+    # For some polymorphic associations (e.g. a has-many-through where the `source`
+    # is polymorphic) we can figure out the type from the class_name or source_type.
+    polymorpic_with_unknowable_klass = (
+      polymorphic_assoc?(reflection) &&
+      !reflection.options.key?(:class_name) &&
+      !reflection.options.key?(:source_type)
+    )
+
+    polymorpic_with_unknowable_klass || !@available_classes.include?(reflection.klass.name)
   end
 
   sig { params(reflection: T.untyped).returns(T.nilable(T::Boolean)) }