sorbet-rails 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7e0b556a5c7db33a8fa24c494fa70265802a360eb842545b6124d54ade20e47
-  data.tar.gz: 5f26a6773d2769e1dfc523f4202b179ded8deaebb65e05ade61291f03153f164
+  metadata.gz: 6ade7fadcb2cc5890f8cd5716247f14d7d9b0324029fb13de4f8b902e205a516
+  data.tar.gz: 766dfdd66acea268fe696345ae871bf4b88cd67e2b845dffeb9f218d9a38586d
 SHA512:
-  metadata.gz: cc61969e6954e727113e9e74ba48925c15ee07b940fbe5d3a711d62270f90ba06ce9c36373420a3cf02c9a52bda3256ef63d9bea6bf2bcd580dfa592faba068c
-  data.tar.gz: 8c0bb6e747de6ac12c77b326b01d941f3f24fdd6444fca05d573ff26c20a2d0d679bbcd713adb37f66919781446137d3f0fdd21bb39b36241c6e1d6a98ac1de6
+  metadata.gz: 91ce6f173680ed297198333b0780c4f4257a7b95d56f33d6f464f67f122c37a6483b87f00392792219ce51724ad5379fea9b7cbf91fc100d439396f828f210be
+  data.tar.gz: ba26ebc1b34724a1eee5cc667add0b843c3ef77994606938e31b2f3fc0a0a88d8a0b7ad39f65194350045166c1eb130cd94951f54c763d82a7efd19dd65ed7a0

data/lib/sorbet-rails/active_record_rbi_formatter.rb

@@ -0,0 +1,295 @@
+# 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!)
+      build_methods.each do |build_method|
+        class_rbi.create_method(
+          build_method,
+          parameters: [
+            Parameter.new("*args", type: "T.untyped"),
+            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,
+        override: true,
+      )
+    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/custom_types/boolean_string.rb

@@ -1,4 +1,6 @@
 # typed: false
+require('sorbet-rails/deprecation.rb')
+
 module BooleanStringImpl
   def is_a?(type)
     return super unless type == BooleanString
@@ -17,6 +19,10 @@ module BooleanStringImpl
 
   def _is_a_boolean_string?
     return @cached_is_a unless @cached_is_a.nil?
+    SorbetRails::TypeAssertDeprecation.deprecation_warning(
+      :BooleanString,
+      'Use TypedParam with T::Boolean type instead.'
+    )
     @cached_is_a = (self =~ /^(true|false)$/i) == 0
   end
 end
@@ -27,6 +33,10 @@ end
 
 class BooleanString < String
   def self.===(other)
+    SorbetRails::TypeAssertDeprecation.deprecation_warning(
+      :BooleanString,
+      'Use TypedParam with T::Boolean type instead.'
+    )
     other.is_a?(BooleanString)
   end
 end

data/lib/sorbet-rails/custom_types/integer_string.rb

@@ -1,4 +1,6 @@
 # typed: false
+require('sorbet-rails/deprecation.rb')
+
 module IntegerStringImpl
   def is_a?(type)
     return super unless type == IntegerString
@@ -17,6 +19,10 @@ module IntegerStringImpl
 
   def _is_a_integer_string?
     return @cached_is_a unless @cached_is_a.nil?
+    SorbetRails::TypeAssertDeprecation.deprecation_warning(
+      :IntegerString,
+      'Use TypedParams with Integer type instead.'
+    )
     Integer(self, 10)
     @cached_is_a = true
   rescue ArgumentError => err
@@ -30,6 +36,10 @@ end
 
 class IntegerString < String
   def self.===(other)
+    SorbetRails::TypeAssertDeprecation.deprecation_warning(
+      :IntegerString,
+      'Use TypedParams with Integer type instead.'
+    )
     other.is_a?(IntegerString)
   end
 end

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/model_plugins/active_record_assoc.rb

@@ -35,7 +35,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 +56,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 +68,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 +114,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: [