sorbet-rails 0.6.3 → 0.7.1

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,14 +29,5 @@ 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)
-      end
-    end
   end
 end

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -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

@@ -1,14 +1,17 @@
 # typed: strict
+require('sorbet-rails/model_column_utils')
 module SorbetRails::ModelUtils
   extend T::Sig
   extend T::Helpers
+  include SorbetRails::ModelColumnUtils
 
   abstract!
 
   # 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
+  # This is also defined in ModelColumnUtils
+  # 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?
@@ -37,6 +40,16 @@ module SorbetRails::ModelUtils
     "#{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) }
   def model_relation_type_alias
     types = [
@@ -73,9 +86,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
@@ -84,34 +101,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

data/lib/sorbet-rails/rails_mixins/generated_url_helpers.rb

@@ -11,6 +11,5 @@
 # + include GeneratedUrlHelpers
 # end
 #
-module GeneratedUrlHelpers
-  include Rails.application.routes.url_helpers
-end
+# Reference: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/routing/route_set.rb
+GeneratedUrlHelpers = Rails.application.routes.url_helpers

data/lib/sorbet-rails/rails_mixins/pluck_to_tstruct.rb

@@ -7,27 +7,37 @@ module SorbetRails::PluckToTStruct
     type_parameters(:U).
     params(
       ta_struct: ITypeAssert[T.type_parameter(:U)],
+      associations: T::Hash[Symbol, String],
     ).
     returns(T::Array[T.type_parameter(:U)])
   }
-  def pluck_to_tstruct(ta_struct)
+  def pluck_to_tstruct(ta_struct, associations: {})
     tstruct = ta_struct.get_type
-  
+
     if !(tstruct < T::Struct)
       raise UnexpectedType.new("pluck_to_tstruct expects a tstruct subclass, given #{tstruct}")
     end
 
-    keys = tstruct.props.keys
+    tstruct_keys = tstruct.props.keys
+    associations_keys = associations.keys
+    invalid_keys = associations_keys - tstruct_keys
+
+    if invalid_keys.any?
+      raise UnexpectedAssociations.new("Argument 'associations' contains keys that don't exist in #{tstruct}: #{invalid_keys.join(", ")}")
+    end
+
+    pluck_keys = (tstruct_keys - associations_keys) + associations.values
 
     # loosely based on pluck_to_hash gem
     # https://github.com/girishso/pluck_to_hash/blob/master/lib/pluck_to_hash.rb
-    keys_one = keys.size == 1
-    pluck(*keys).map do |row|
+    keys_one = pluck_keys.size == 1
+    pluck(*pluck_keys).map do |row|
       row = [row] if keys_one
-      value = Hash[keys.zip(row)]
+      value = Hash[tstruct_keys.zip(row)]
       tstruct.new(value)
     end
   end
-  
+
   class UnexpectedType < StandardError; end
+  class UnexpectedAssociations < StandardError; end
 end

data/lib/sorbet-rails/railtie.rb

@@ -50,9 +50,7 @@ class SorbetRails::Railtie < Rails::Railtie
     end
 
     ActiveSupport.on_load(:action_controller) do
-      require "sorbet-rails/rails_mixins/custom_params_methods"
       require "sorbet-rails/rails_mixins/generated_url_helpers"
-      ActionController::Parameters.include SorbetRails::CustomParamsMethods
     end
 
     SorbetRails.register_configured_plugins

data/lib/sorbet-rails/sorbet_utils.rb

@@ -5,168 +5,170 @@ require('sorbet-runtime')
 require('method_source')
 require('parser/current')
 
-module SorbetRails::SorbetUtils
-  extend T::Sig
-  include Kernel
-
-  class ParsedParamDef < T::Struct
-    const :name, Symbol
-    const :kind, Symbol
-    const :type_str, String
-    prop :default, T.nilable(String), default: nil
-    prop :prefix, T.nilable(String)
-    prop :suffix, T.nilable(String)
-  end
-
-  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)
-    method_def = signature.nil? ? method_def : signature.method
-
-    parameters_with_type = signature.nil? ?
-      method_def.parameters.map { |p|
-        ParsedParamDef.new(
-          name: p.size == 1 ? :_ : p[1],  # give param without name default name _
-          kind: p[0], # append untyped as type of each param
-          type_str: 'T.untyped',
-        )
-      } :
-      get_ordered_parameters_with_type(signature)
-
-    # add prefix & suffix
-    parameters_with_type.each do |param_def|
-      param_def.prefix =
-        case param_def.kind
-        when :rest; '*'
-        when :keyrest; '**'
-        when :block; '&'
-        # being comprehensive
-        when :req, :opt; ''
-        when :key, :keyreq; ''
-        else nil
-        end
-
-      param_def.suffix =
-        case param_def.kind
-        when :key, :keyreq; ':'
-        else nil
-        end
+module SorbetRails
+  module SorbetUtils
+    extend T::Sig
+    include Kernel
+
+    class ParsedParamDef < T::Struct
+      const :name, Symbol
+      const :kind, Symbol
+      const :type_str, String
+      prop :default, T.nilable(String), default: nil
+      prop :prefix, T.nilable(String)
+      prop :suffix, T.nilable(String)
     end
 
-    extract_default_value_for_params!(
-      parameters_with_type,
-      method_def,
-    )
-
-    parameters_with_type.map do |param_def|
-      ::Parlour::RbiGenerator::Parameter.new(
-        "#{param_def.prefix}#{param_def.name}#{param_def.suffix}",
-        type: param_def.type_str,
-        default: param_def.default,
+    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)
+      method_def = signature.nil? ? method_def : signature.method
+
+      parameters_with_type = signature.nil? ?
+        method_def.parameters.map { |p|
+          ParsedParamDef.new(
+            name: p.size == 1 ? :_ : p[1],  # give param without name default name _
+            kind: p[0], # append untyped as type of each param
+            type_str: 'T.untyped',
+          )
+        } :
+        get_ordered_parameters_with_type(signature)
+
+      # add prefix & suffix
+      parameters_with_type.each do |param_def|
+        param_def.prefix =
+          case param_def.kind
+          when :rest; '*'
+          when :keyrest; '**'
+          when :block; '&'
+          # being comprehensive
+          when :req, :opt; ''
+          when :key, :keyreq; ''
+          else nil
+          end
+
+        param_def.suffix =
+          case param_def.kind
+          when :key, :keyreq; ':'
+          else nil
+          end
+      end
+
+      extract_default_value_for_params!(
+        parameters_with_type,
+        method_def,
       )
-    end
-  end
 
-  sig {
-    params(signature: T::Private::Methods::Signature).
-    returns(T::Array[ParsedParamDef])
-  }
-  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 = T.let([], T::Array[ParsedParamDef])
-    signature.arg_types.each do |arg_type|
-      # could be :opt, but doesn't matter
-      params << ParsedParamDef.new(
-        name: arg_type[0],
-        kind: :req,
-        type_str: arg_type[1].to_s,
-      )
-    end
-    signature.kwarg_types.each do |kwarg_name, kwarg_type|
-      # could be :key, but doesn't matter
-      params << ParsedParamDef.new(
-        name: kwarg_name,
-        kind: :keyreq,
-        type_str: kwarg_type.to_s,
-      )
-    end
-    if signature.has_rest
-      params << ParsedParamDef.new(
-        name: signature.rest_name,
-        kind: :rest,
-        type_str: signature.rest_type.to_s,
-      )
-    end
-    if signature.has_keyrest
-      params << ParsedParamDef.new(
-        name: signature.keyrest_name,
-        kind: :keyrest,
-        type_str: signature.keyrest_type.to_s,
-      )
-    end
-    if !signature.block_name.nil?
-      # special case `.void` in a proc
-      # see https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/types/proc.rb#L10
-      block_param_type = signature.block_type.to_s
-      block_param_type = block_param_type.gsub('returns(<VOID>)', 'void')
-      params << ParsedParamDef.new(
-        name: signature.block_name,
-        kind: :block,
-        type_str: block_param_type,
-      )
+      parameters_with_type.map do |param_def|
+        ::Parlour::RbiGenerator::Parameter.new(
+          "#{param_def.prefix}#{param_def.name}#{param_def.suffix}",
+          type: param_def.type_str,
+          default: param_def.default,
+        )
+      end
     end
-    params
-  end
 
-  sig {
-    params(
-      parsed_params: T::Array[ParsedParamDef],
-      method_def: UnboundMethod,
-    ).void
-  }
-  def self.extract_default_value_for_params!(parsed_params, method_def)
-    source = method_def.source
-    parsed_ast = Parser::CurrentRuby.parse(source)
-    if parsed_ast.type != :def
-      # could be a method added at runtime? ignore it
-      puts "Warning: unable to parse the source of #{method_def.name}"
-      return
+    sig {
+      params(signature: T::Private::Methods::Signature).
+      returns(T::Array[ParsedParamDef])
+    }
+    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 = T.let([], T::Array[ParsedParamDef])
+      signature.arg_types.each do |arg_type|
+        # could be :opt, but doesn't matter
+        params << ParsedParamDef.new(
+          name: arg_type[0],
+          kind: :req,
+          type_str: arg_type[1].to_s,
+        )
+      end
+      signature.kwarg_types.each do |kwarg_name, kwarg_type|
+        # could be :key, but doesn't matter
+        params << ParsedParamDef.new(
+          name: kwarg_name,
+          kind: :keyreq,
+          type_str: kwarg_type.to_s,
+        )
+      end
+      if signature.has_rest
+        params << ParsedParamDef.new(
+          name: signature.rest_name,
+          kind: :rest,
+          type_str: signature.rest_type.to_s,
+        )
+      end
+      if signature.has_keyrest
+        params << ParsedParamDef.new(
+          name: signature.keyrest_name,
+          kind: :keyrest,
+          type_str: signature.keyrest_type.to_s,
+        )
+      end
+      if !signature.block_name.nil?
+        # special case `.void` in a proc
+        # see https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/types/proc.rb#L10
+        block_param_type = signature.block_type.to_s
+        block_param_type = block_param_type.gsub('returns(<VOID>)', 'void')
+        params << ParsedParamDef.new(
+          name: signature.block_name,
+          kind: :block,
+          type_str: block_param_type,
+        )
+      end
+      params
     end
 
-    args = parsed_ast.children[1]
-    if args.type != :args
-      puts "Warning: unable to parse the source of #{method_def.name}"
-      return
+    sig {
+      params(
+        parsed_params: T::Array[ParsedParamDef],
+        method_def: UnboundMethod,
+      ).void
+    }
+    def self.extract_default_value_for_params!(parsed_params, method_def)
+      source = method_def.source
+      parsed_ast = Parser::CurrentRuby.parse(source)
+      if parsed_ast.type != :def
+        # could be a method added at runtime? ignore it
+        puts "Warning: unable to parse the source of #{method_def.name}"
+        return
+      end
+
+      args = parsed_ast.children[1]
+      if args.type != :args
+        puts "Warning: unable to parse the source of #{method_def.name}"
+        return
+      end
+
+      parsed_params_map = Hash[parsed_params.map {|p| [p.name, p]}]
+      args.children.each do |arg|
+        arg_name = arg.children[0]
+        default = arg.children[1] ? node_to_s(arg.children[1]) : nil
+
+        next if arg_name.blank?
+
+        param_def = parsed_params_map[arg_name]
+
+        raise UnexpectedParam.new(
+          "Unexpected param #{arg_name} when parsing #{method_def.name}"
+        ) unless param_def.present?
+
+        param_def.default = default
+      end
     end
 
-    parsed_params_map = Hash[parsed_params.map {|p| [p.name, p]}]
-    args.children.each do |arg|
-      arg_name = arg.children[0]
-      default = arg.children[1] ? node_to_s(arg.children[1]) : nil
-
-      next if arg_name.blank?
-
-      param_def = parsed_params_map[arg_name]
-
-      raise UnexpectedParam.new(
-        "Unexpected param #{arg_name} when parsing #{method_def.name}"
-      ) unless param_def.present?
+    # Given an AST node, returns the source code from which it was constructed.
+    # If the given AST node is nil, this returns nil.
+    # Taken from https://github.com/AaronC81/parlour/blob/master/lib/parlour/type_parser.rb#L506
+    sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
+    def self.node_to_s(node)
+      return nil unless node
 
-      param_def.default = default
+      exp = node.loc.expression
+      exp.source_buffer.source[exp.begin_pos...exp.end_pos]
     end
-  end
-
-  # Given an AST node, returns the source code from which it was constructed.
-  # If the given AST node is nil, this returns nil.
-  # Taken from https://github.com/AaronC81/parlour/blob/master/lib/parlour/type_parser.rb#L506
-  sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
-  def self.node_to_s(node)
-    return nil unless node
 
-    exp = node.loc.expression
-    exp.source_buffer.source[exp.begin_pos...exp.end_pos]
+    class UnexpectedParam < StandardError; end
   end
-
-  class UnexpectedParam < StandardError; end
 end