sorbet-rails 0.6.5.1 → 0.7.4

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

@@ -30,14 +30,12 @@ module SorbetRails::ModelPlugins
       @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
+    sig { params(column_name: String).returns(T.nilable(Class)) }
+    def serialization_coder_for_column(column_name)
+      column_type = @model_class.type_for_attribute(column_name)
+      return unless column_type.is_a?(ActiveRecord::Type::Serialized)
+
+      column_type.coder.try(:object_class) || Object
     end
   end
 end

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

@@ -6,6 +6,7 @@ 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_serialized_attribute')
 require('sorbet-rails/model_plugins/custom_finder_methods')
 require('sorbet-rails/model_plugins/enumerable_collections')
 require('sorbet-rails/model_plugins/active_storage_methods')
@@ -47,6 +48,8 @@ module SorbetRails::ModelPlugins
       ActiveRecordQuerying
     when :active_relation_where_not
       ActiveRelationWhereNot
+    when :active_record_serialized_attribute
+      ActiveRecordSerializedAttribute
     when :active_record_attribute
       ActiveRecordAttribute
     when :active_record_assoc
@@ -78,6 +81,12 @@ module SorbetRails::ModelPlugins
     when :paperclip
       require('sorbet-rails/gem_plugins/paperclip_plugin')
       PaperclipPlugin
+    when :attr_json
+      require('sorbet-rails/gem_plugins/attr_json_plugin')
+      AttrJsonPlugin
+    when :flag_shih_tzu
+      require('sorbet-rails/gem_plugins/flag_shih_tzu_plugin')
+      FlagShihTzuPlugin
     else
       raise UnrecognizedPluginName.new(
         "Unrecognized plugin with name: #{plugin_name}. Please check available plugins in the

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -42,7 +42,7 @@ class SorbetRails::ModelRbiFormatter
     end
 
     generator = Parlour::RbiGenerator.new(break_params: 3)
-    run_plugins(plugin_instances, generator, allow_failure: true)
+    run_plugins(plugin_instances, generator)
     # Generate the base after the plugins because when ConflictResolver merge the modules,
     # it'll put the modules at the last position merged. Putting the base stuff
     # last will keep the order consistent and minimize changes when new plugins are added.
@@ -115,11 +115,11 @@ class SorbetRails::ModelRbiFormatter
     params(
       plugins: T::Array[Parlour::Plugin],
       generator: Parlour::RbiGenerator,
-      allow_failure: T::Boolean,
     ).
     void
   }
-  def run_plugins(plugins, generator, allow_failure: true)
+  def run_plugins(plugins, generator)
+    allow_failure = ENV["SBR_DEBUG_MODE"] == "true"
     plugins.each do |plugin|
       begin
         generator.current_plugin = plugin

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?

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

@@ -3,31 +3,78 @@ require 'sorbet-runtime'
 
 module SorbetRails::PluckToTStruct
   extend T::Sig
+
+  NILCLASS_STRING = "NilClass".freeze
+
   sig {
     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_props = tstruct.props
+    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[map_nil_values_to_default(tstruct_props, tstruct_keys.zip(row))]
       tstruct.new(value)
     end
   end
-  
+
+  sig {params(type_object: T::Types::Base).returns(T::Boolean)}
+  private def nilable?(type_object)
+    return false unless type_object.is_a?(T::Types::Union)
+
+    type_object.types.any? { |type| type.name == NILCLASS_STRING }
+  end
+
+  sig {
+    params(
+      tstruct_props: T::Hash[Symbol, T.untyped],
+      zipped_rows: T::Array[[Symbol, T.untyped]]
+    )
+    .returns(T::Array[[Symbol, T.untyped]])
+  }
+  private def map_nil_values_to_default(tstruct_props, zipped_rows)
+    # we use the default value defined on a prop if
+    # 1. the plucked value is nil
+    # 2. the prop has a default
+    # 3. the prop's type isn't nilable
+
+    zipped_rows.map do |key, value|
+      next [key, value] unless value.nil?
+
+      default = tstruct_props.dig(key, :default)
+      next [key, value] unless default
+
+      type_object = tstruct_props.dig(key, :type_object)
+      next [key, value] if nilable?(type_object)
+
+      [key, default]
+    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/routes_rbi_formatter.rb

@@ -19,7 +19,7 @@ class SorbetRails::RoutesRbiFormatter
 
   sig { params(routes: T.untyped).void }
   def header(routes)
-    @parlour.root.add_comments([
+    @parlour.root.add_comment([
       'This is an autogenerated file for Rails routes.',
       'Please run bundle exec rake rails_rbi:routes to regenerate.'
     ])
@@ -28,6 +28,10 @@ class SorbetRails::RoutesRbiFormatter
       klass.create_include('GeneratedUrlHelpers')
     end
 
+    @parlour.root.create_class('ActionController::API') do |klass|
+      klass.create_include('GeneratedUrlHelpers')
+    end
+
     @parlour.root.create_module('ActionView::Helpers') do |mod|
       mod.create_include('GeneratedUrlHelpers')
     end
@@ -39,7 +43,7 @@ class SorbetRails::RoutesRbiFormatter
 
   sig { params(routes: T.untyped, filter: T.untyped).void }
   def no_routes(routes = nil, filter = nil)
-    @parlour.root.add_comments([
+    @parlour.root.add_comment([
       'You do not have any routes defined!',
       'Please add some routes in config/routes.rb.',
       'For more information about routes, see the Rails guide: https://guides.rubyonrails.org/routing.html.'

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