sorbet-rails 0.6.2 → 0.7.0

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

@@ -12,8 +12,9 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     sig { returns(String) }
     def to_s
       type = base_type.to_s
-      type = "T.nilable(#{type})" if nilable
+      # A nullable array column should be T.nilable(T::Array[column_type]) not T::Array[T.nilable(column_type)]
       type = "T::Array[#{type}]" if array_type
+      type = "T.nilable(#{type})" if nilable
       type
     end
   end
@@ -25,7 +26,6 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
 
     attribute_module_name = self.model_module_name("GeneratedAttributeMethods")
     attribute_module_rbi = root.create_module(attribute_module_name)
-    attribute_module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(attribute_module_name)
@@ -82,6 +82,7 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     column_def
   )
     should_skip_setter_getter = false
+    nilable_column = nilable_column?(column_def)
 
     if @model_class.is_a?(::ActiveRecord::Enum)
       config = @model_class.typed_enum_reflections[column_name]
@@ -89,19 +90,19 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
         # do not generate the methods for enums in strict_mode
         should_skip_setter_getter = config.strict_mode
 
-        t_enum_type = "#{@model_class.name}::#{config.class_name}"
+        t_enum_type = "#{model_class_name}::#{config.class_name}"
 
         # define T::Enum class & values
         enum_values = T.must(model_defined_enums[column_name])
         t_enum_values = @model_class.gen_typed_enum_values(enum_values.keys)
         root.create_enum_class(
           t_enum_type,
-          enums: t_enum_values.map { |k, v| [v, "'#{k}'"] },
+          enums: t_enum_values.map { |k, v| [v, "%q{#{k}}"] },
         )
 
         # define t_enum setter/getter
         assignable_type = t_enum_type
-        assignable_type = "T.nilable(#{assignable_type})" if column_def.null
+        assignable_type = "T.nilable(#{assignable_type})" if nilable_column
         # add directly to model_class_rbi because they are included
         # by sorbet's hidden.rbi
         model_class_rbi.create_method(
@@ -121,9 +122,9 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     if !should_skip_setter_getter
       # enum attribute is treated differently
       assignable_type = "T.any(Integer, String, Symbol)"
-      assignable_type = "T.nilable(#{assignable_type})" if column_def.null
+      assignable_type = "T.nilable(#{assignable_type})" if nilable_column
       return_type = "String"
-      return_type = "T.nilable(#{return_type})" if column_def.null
+      return_type = "T.nilable(#{return_type})" if nilable_column
 
       attribute_module_rbi.create_method(
         column_name.to_s,
@@ -145,6 +146,11 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
       ActiveRecord::Base.connection.lookup_cast_type_from_column(column_def) :
       column_def.cast_type
 
+    array_type = false
+    if column_def.try(:array?)
+      cast_type = cast_type.subtype if cast_type.try(:subtype)
+      array_type = true
+    end
     strict_type =
       active_record_type_to_sorbet_type(
         cast_type,
@@ -153,8 +159,8 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
 
     ColumnType.new(
       base_type: strict_type,
-      nilable: column_def.null,
-      array_type: column_def.try(:array?),
+      nilable: nilable_column?(column_def),
+      array_type: array_type,
     )
   end
 
@@ -214,6 +220,11 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     )
   end
 
+  sig { params(column_def: T.untyped).returns(T::Boolean) }
+  def nilable_column?(column_def)
+    !!(column_def.null && !attribute_has_unconditional_presence_validation?(column_def.name))
+  end
+
   sig { params(column_type: ColumnType).returns(String) }
   def value_type_for_attr_writer(column_type)
     # it's safe - and convenient - to assign any "time like" object to a time zone

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

@@ -9,7 +9,6 @@ class SorbetRails::ModelPlugins::ActiveRecordEnum < SorbetRails::ModelPlugins::B
 
     enum_module_name = model_module_name("EnumInstanceMethods")
     enum_module_rbi = root.create_module(enum_module_name)
-    enum_module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(enum_module_name)

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

@@ -7,15 +7,24 @@ class SorbetRails::ModelPlugins::ActiveRecordNamedScope < SorbetRails::ModelPlug
   def generate(root)
     model_class_rbi = root.create_class(self.model_class_name)
 
-    @model_class.methods.sort.each do |method_name|
+    # Named scope methods are dynamically defined by the `scope` method so their
+    # source_location is `lib/active_record/scoping/named.rb`. So we find scopes
+    # by two criteria:
+    # - they are defined in 'activerecord/lib/active_record/scoping/named.rb'
+    # - they are not one of the methods actually defined in that file's source.
+    # See: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/scoping/named.rb
+    non_dynamic_methods = (
+      ActiveRecord::Scoping::Named::ClassMethods.instance_methods +
+      ActiveRecord::Scoping::Named::ClassMethods.protected_instance_methods +
+      ActiveRecord::Scoping::Named::ClassMethods.private_instance_methods
+    )
+
+    (@model_class.methods - non_dynamic_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:
-      # - they don't have an owner name
-      # - they are defined in 'activerecord/lib/active_record/scoping/named.rb'
-      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/scoping/named.rb
-      next unless method_obj.owner.name == nil
+
       source_file = method_obj.source_location[0]
       next unless source_file.include?("lib/active_record/scoping/named.rb")
 

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

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 require ('sorbet-rails/model_plugins/base')
 class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugins::Base
 
@@ -9,6 +9,7 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
     add_relation_query_method(
       root,
       "all",
+      builtin_query_method: true,
     )
     add_relation_query_method(
       root,
@@ -16,6 +17,7 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
       parameters: [
         Parameter.new("&block", type: "T.nilable(T.proc.void)"),
       ],
+      builtin_query_method: true,
     )
 
     # It's not possible to typedef all methods in ActiveRecord::Querying module to have the
@@ -34,6 +36,7 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
         parameters: [
           Parameter.new("*args", type: "T.untyped"),
         ],
+        builtin_query_method: true,
       ) if exists_class_method?(method_name)
     end
 
@@ -43,7 +46,35 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
       parameters: [
         Parameter.new("*args", type: "T.untyped"),
         Parameter.new("&block", type: "T.nilable(T.proc.void)"),
-      ]
+      ],
+      builtin_query_method: true,
+    )
+
+    # These are technically "query methods" but they aren't chainable so instead of
+    # adding conditionals to `add_relation_query_method` to handle this we'll just
+    # handle them here.
+    relation_module_rbi = root.create_module(self.model_query_methods_returning_relation_module_name)
+    create_in_batches_method(relation_module_rbi, inner_type: self.model_relation_class_name)
+
+    assoc_relation_module_rbi = root.create_module(self.model_query_methods_returning_assoc_relation_module_name)
+    create_in_batches_method(assoc_relation_module_rbi, inner_type: self.model_assoc_relation_class_name)
+  end
+
+  private
+
+  sig { params(root: Parlour::RbiGenerator::Namespace, inner_type: String).void }
+  def create_in_batches_method(root, inner_type:)
+    root.create_method(
+      "in_batches",
+      parameters: [
+        Parameter.new("of:", type: "T.nilable(Integer)", default: "1000"),
+        Parameter.new("start:", type: "T.nilable(Integer)", default: "nil"),
+        Parameter.new("finish:", type: "T.nilable(Integer)", default: "nil"),
+        Parameter.new("load:", type: "T.nilable(T::Boolean)", default: "false"),
+        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: "ActiveRecord::Batches::BatchEnumerator",
     )
   end
-end
+end

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

@@ -52,7 +52,7 @@ class SorbetRails::ModelPlugins::ActiveStorageMethods < SorbetRails::ModelPlugin
     mod.create_method(
       "#{assoc_name}=",
       parameters: [
-        Parameter.new('*attachables', type: 'T.untyped')
+        Parameter.new('attachables', type: 'T.untyped')
       ],
       return_type: 'T.untyped'
     )

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

@@ -29,5 +29,15 @@ module SorbetRails::ModelPlugins
       @model_class = T.let(model_class, T.class_of(ActiveRecord::Base))
       @available_classes = T.let(available_classes, T::Set[String])
     end
+
+    sig { params(attribute: T.any(String, Symbol)).returns(T::Boolean) }
+    def attribute_has_unconditional_presence_validation?(attribute)
+      model_class.validators_on(attribute).any? do |validator|
+        validator.is_a?(ActiveModel::Validations::PresenceValidator) &&
+          !validator.options.key?(:if) &&
+          !validator.options.key?(:unless) &&
+          !validator.options.key?(:on)
+      end
+    end
   end
 end

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

@@ -4,16 +4,7 @@ class SorbetRails::ModelPlugins::EnumerableCollections < SorbetRails::ModelPlugi
 
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
-    # 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, include_methods: false)
-
-    model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
-    create_enumerable_methods_for(model_assoc_relation_rbi)
-
     model_assoc_proxy_class_rbi = root.create_class(self.model_assoc_proxy_class_name)
-    create_enumerable_methods_for(model_assoc_proxy_class_rbi)
 
     # following methods only exists in an association proxy
     ["<<", "append", "push", "concat"].each do |method_name|
@@ -27,45 +18,4 @@ class SorbetRails::ModelPlugins::EnumerableCollections < SorbetRails::ModelPlugi
       )
     end
   end
-
-  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")
-
-    # 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

@@ -6,7 +6,6 @@ require('sorbet-rails/model_plugins/active_relation_where_not')
 require('sorbet-rails/model_plugins/active_record_named_scope')
 require('sorbet-rails/model_plugins/active_record_attribute')
 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_storage_methods')
@@ -52,8 +51,6 @@ module SorbetRails::ModelPlugins
       ActiveRecordAttribute
     when :active_record_assoc
       ActiveRecordAssoc
-    when :active_record_finder_methods
-      ActiveRecordFinderMethods
     when :custom_finder_methods
       CustomFinderMethods
     when :enumerable_collections

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -28,13 +28,13 @@ class SorbetRails::ModelRbiFormatter
       # Load all dynamic instance methods of this model by instantiating a fake model
       @model_class.new unless @model_class.abstract_class?
     rescue StandardError => err
-      puts "#{err.class}: Note: Unable to create new instance of #{model_class.name}"
+      puts "#{err.class}: Note: Unable to create new instance of #{model_class_name}"
     end
   end
 
   sig {returns(String)}
   def generate_rbi
-    puts "-- Generate sigs for #{@model_class.name} --"
+    puts "-- Generate sigs for #{model_class_name} --"
 
     # Collect the instances of each plugin into an array
     plugin_instances = self.class.get_plugins.map do |plugin_klass|
@@ -74,8 +74,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_relation_class_name,
       superclass: "ActiveRecord::Relation",
     )
-    model_relation_rbi.create_extend("T::Sig")
-    model_relation_rbi.create_extend("T::Generic")
+    model_relation_rbi.create_include(self.model_query_methods_returning_relation_module_name)
     model_relation_rbi.create_constant(
       "Elem",
       value: "type_member(fixed: #{model_class_name})",
@@ -85,8 +84,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_assoc_relation_class_name,
       superclass: "ActiveRecord::AssociationRelation",
     )
-    model_assoc_relation_rbi.create_extend("T::Sig")
-    model_assoc_relation_rbi.create_extend("T::Generic")
+    model_assoc_relation_rbi.create_include(self.model_query_methods_returning_assoc_relation_module_name)
     model_assoc_relation_rbi.create_constant(
       "Elem",
       value: "type_member(fixed: #{model_class_name})",
@@ -96,8 +94,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_assoc_proxy_class_name,
       superclass: "ActiveRecord::Associations::CollectionProxy",
     )
-    collection_proxy_rbi.create_extend("T::Sig")
-    collection_proxy_rbi.create_extend("T::Generic")
+    collection_proxy_rbi.create_include(self.model_query_methods_returning_assoc_relation_module_name)
     collection_proxy_rbi.create_constant(
       "Elem",
       value: "type_member(fixed: #{self.model_class_name})",
@@ -107,8 +104,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_class_name,
       superclass: T.must(@model_class.superclass).name,
     )
-    model_rbi.create_extend("T::Sig")
-    model_rbi.create_extend("T::Generic")
+    model_rbi.create_extend(self.model_query_methods_returning_relation_module_name)
     model_rbi.create_type_alias(
       self.model_relation_type_class_name,
       type: self.model_relation_type_alias

data/lib/sorbet-rails/model_utils.rb

@@ -5,27 +5,46 @@ module SorbetRails::ModelUtils
 
   abstract!
 
-  sig { abstract.returns(T.class_of(ActiveRecord::Base)) }
+  # if we're a HABTM class then model_class is an anonymous class (see the rails link below) and
+  # i'm not sure how to explain that to sorbet other than T.class_of(Class).
+  sig { abstract.returns(T.any(T.class_of(ActiveRecord::Base), T.class_of(Class))) }
   def model_class; end
 
+  sig { returns(T::Boolean) }
+  def habtm_class?
+    # checking the class name seems to be the cleanest way to figure this out, see:
+    # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb#L54
+    T.must(model_class.name).start_with?('HABTM_')
+  end
+
   sig { returns(String) }
   def model_class_name
-    "#{model_class.name}"
+    model_class.to_s
   end
 
   sig { returns(String) }
   def model_relation_class_name
-    "#{model_class.name}::ActiveRecord_Relation"
+    "#{model_class_name}::ActiveRecord_Relation"
   end
 
   sig { returns(String) }
   def model_assoc_proxy_class_name
-    "#{model_class.name}::ActiveRecord_Associations_CollectionProxy"
+    "#{model_class_name}::ActiveRecord_Associations_CollectionProxy"
   end
 
   sig { returns(String) }
   def model_assoc_relation_class_name
-    "#{model_class.name}::ActiveRecord_AssociationRelation"
+    "#{model_class_name}::ActiveRecord_AssociationRelation"
+  end
+
+  sig { returns(String) }
+  def model_query_methods_returning_relation_module_name
+    "#{model_class_name}::QueryMethodsReturningRelation"
+  end
+
+  sig { returns(String) }
+  def model_query_methods_returning_assoc_relation_module_name
+    "#{model_class_name}::QueryMethodsReturningAssociationRelation"
   end
 
   sig { returns(String) }
@@ -46,7 +65,7 @@ module SorbetRails::ModelUtils
 
   sig { params(module_name: String).returns(String) }
   def model_module_name(module_name)
-    "#{model_class.name}::#{module_name}"
+    "#{model_class_name}::#{module_name}"
   end
 
   sig { params(method_name: T.any(String, Symbol)).returns(T::Boolean) }
@@ -64,9 +83,13 @@ module SorbetRails::ModelUtils
       root: Parlour::RbiGenerator::Namespace,
       method_name: String,
       parameters: T.nilable(T::Array[::Parlour::RbiGenerator::Parameter]),
+      # This is meant to indicate the method is a rails-provided query method like
+      # where, limit, etc and not something like a named scope. It should likely
+      # only be set to `true` when called from the ActiveRecordQuerying plugin.
+      builtin_query_method: T::Boolean,
     ).void
   }
-  def add_relation_query_method(root, method_name, parameters: nil)
+  def add_relation_query_method(root, method_name, parameters: nil, builtin_query_method: false)
     # a relation querying method will be available on
     # - model (as a class method)
     # - activerecord relation
@@ -75,34 +98,58 @@ module SorbetRails::ModelUtils
     # in case (1) and (2), it returns a Model::ActiveRecord_Relation
     # in case (3) and (4), it returns a Model::ActiveRecord_AssociationRelation
 
-    # force generating these methods because sorbet's hidden-definitions generate & override them
-    model_class_rbi = root.create_class(self.model_class_name)
-    model_class_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_relation_class_name,
-      class_method: true,
-    )
-
-    model_relation_rbi = root.create_class(self.model_relation_class_name)
-    model_relation_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_relation_class_name,
-    )
-
-    model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
-    model_assoc_relation_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_assoc_relation_class_name,
-    )
-
-    collection_proxy_rbi = root.create_class(self.model_assoc_proxy_class_name)
-    collection_proxy_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_assoc_relation_class_name,
-    )
+    # 'unscoped' is a special case where it always returns a ActiveRecord_Relation
+    assoc_return_value = method_name == 'unscoped' ? self.model_relation_class_name : self.model_assoc_relation_class_name
+
+    # We can put methods onto modules which are extended/included by the model
+    # and relation classes which reduces the RBI footprint for an individual
+    # model. However, in Rails 5 query methods that come from scopes or enums
+    # get overridden in hidden-definitions so we need to explicitly define them
+    # on the model and relation classes.
+    if builtin_query_method
+      relation_module_rbi = root.create_module(self.model_query_methods_returning_relation_module_name)
+      relation_module_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: self.model_relation_class_name,
+      )
+
+      assoc_relation_module_rbi = root.create_module(self.model_query_methods_returning_assoc_relation_module_name)
+      assoc_relation_module_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: assoc_return_value,
+      )
+    else
+      # force generating these methods because sorbet's hidden-definitions generate & override them
+      model_class_rbi = root.create_class(self.model_class_name)
+      model_class_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: self.model_relation_class_name,
+        class_method: true,
+      )
+
+      model_relation_rbi = root.create_class(self.model_relation_class_name)
+      model_relation_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: self.model_relation_class_name,
+      )
+
+      model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
+      model_assoc_relation_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: assoc_return_value,
+      )
+
+      collection_proxy_rbi = root.create_class(self.model_assoc_proxy_class_name)
+      collection_proxy_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: assoc_return_value,
+      )
+    end
   end
 end