sorbet-rails 0.6.5 → 0.7.3

data/lib/sorbet-rails/mailer_rbi_formatter.rb

@@ -2,37 +2,50 @@
 require('parlour')
 require('sorbet-rails/sorbet_utils.rb')
 
-class SorbetRails::MailerRbiFormatter
-  extend T::Sig
+module SorbetRails
+  class MailerRbiFormatter
+    extend T::Sig
 
-  sig { params(mailer_class: T.class_of(ActionMailer::Base)).void }
-  def initialize(mailer_class)
-    @mailer_class = T.let(mailer_class, T.class_of(ActionMailer::Base))
-    @parlour = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
-  end
+    Parameter = ::Parlour::RbiGenerator::Parameter
+
+    sig { returns(Parlour::RbiGenerator) }
+    attr_reader :rbi_generator
 
-  sig {returns(String)}
-  def generate_rbi
-    puts "-- Generate sigs for mailer #{@mailer_class.name} --"
-
-    @parlour.root.add_comments([
-      "This is an autogenerated file for Rails' mailers.",
-      'Please rerun bundle exec rake rails_rbi:mailers to regenerate.'
-    ])
-
-    @parlour.root.create_class(@mailer_class.name) do |mailer_rbi|
-      @mailer_class.action_methods.to_a.sort.each do |mailer_method|
-        method_def = @mailer_class.instance_method(mailer_method)
-        parameters = SorbetRails::SorbetUtils.parameters_from_method_def(method_def)
-        mailer_rbi.create_method(
-          mailer_method,
-          parameters: parameters,
-          return_type: 'ActionMailer::MessageDelivery',
-          class_method: true,
-        )
+    sig { returns(T.class_of(ActionMailer::Base)) }
+    attr_reader :mailer_class
+
+    sig { params(mailer_class: T.class_of(ActionMailer::Base)).void }
+    def initialize(mailer_class)
+      @mailer_class = T.let(mailer_class, T.class_of(ActionMailer::Base))
+      @rbi_generator = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
+    end
+
+    sig { void }
+    def populate_rbi
+      @rbi_generator.root.add_comment([
+        "This is an autogenerated file for Rails' mailers.",
+        'Please rerun bundle exec rake rails_rbi:mailers to regenerate.'
+      ])
+
+      @rbi_generator.root.create_class(T.must(@mailer_class.name)) do |mailer_rbi|
+        @mailer_class.action_methods.to_a.sort.each do |mailer_method|
+          method_def = @mailer_class.instance_method(mailer_method)
+          parameters = SorbetRails::SorbetUtils.parameters_from_method_def(method_def)
+          mailer_rbi.create_method(
+            mailer_method.to_s,
+            parameters: parameters,
+            return_type: 'ActionMailer::MessageDelivery',
+            class_method: true,
+          )
+        end
       end
     end
 
-    @parlour.rbi
+    sig { returns(String) }
+    def generate_rbi
+      puts "-- Generate sigs for mailer #{@mailer_class.name} --"
+      populate_rbi
+      @rbi_generator.rbi
+    end
   end
 end

data/lib/sorbet-rails/model_column_utils.rb

@@ -0,0 +1,129 @@
+# typed: strict
+module SorbetRails::ModelColumnUtils
+  extend T::Sig
+  extend T::Helpers
+
+  abstract!
+
+  class ColumnType < T::Struct
+    extend T::Sig
+
+    const :base_type, T.any(Class, String)
+    const :nilable, T.nilable(T::Boolean)
+    const :array_type,  T.nilable(T::Boolean)
+
+    sig { returns(String) }
+    def to_s
+      type = base_type.to_s
+      # 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
+
+  # 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 { params(column_def: T.untyped).returns(ColumnType) }
+  def type_for_column_def(column_def)
+    cast_type = ActiveRecord::Base.connection.respond_to?(:lookup_cast_type_from_column) ?
+      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,
+        time_zone_aware: time_zone_aware_column?(column_def, cast_type),
+      )
+
+    ColumnType.new(
+      base_type: strict_type,
+      nilable: nilable_column?(column_def),
+      array_type: array_type,
+    )
+  end
+
+  # True if this column is "time zone aware", which means it'll be converted on
+  # access from its original class (e.g. `DateTime`) to something with better
+  # support for time zones (usually `ActiveSupport::TimeWithZone`)
+  sig do
+    params(column_def: T.untyped, cast_type: T.untyped).returns(T::Boolean)
+  end
+  def time_zone_aware_column?(column_def, cast_type)
+    # this private class method returns true if the attribute should be "time
+    # zone aware"; it takes into account various global and model-specific
+    # configuration options as described here:
+    # https://api.rubyonrails.org/classes/ActiveRecord/Timestamp.html
+    #
+    # although it's private, it's better this than trying to reimplement the "is
+    # this attribute tz aware?" logic ourselves
+    model_class.send(
+      :create_time_zone_conversion_attribute?,
+      column_def.name,
+      cast_type
+    )
+  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 do
+    params(
+      klass: Object,
+      time_zone_aware: T::Boolean,
+    ).returns(T.any(String, Class))
+  end
+  def active_record_type_to_sorbet_type(klass, time_zone_aware: false)
+    case klass
+    when ActiveRecord::Type::Boolean
+      "T::Boolean"
+    when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
+      time_zone_aware ? ActiveSupport::TimeWithZone : Time
+    when ActiveRecord::Type::Date
+      Date
+    when ActiveRecord::Type::Decimal
+      BigDecimal
+    when ActiveRecord::Type::Float
+      Float
+    when ActiveRecord::Type::BigInteger, ActiveRecord::Type::Integer, ActiveRecord::Type::DecimalWithoutScale, ActiveRecord::Type::UnsignedInteger
+      Integer
+    when ActiveRecord::Type::Binary, ActiveRecord::Type::String, ActiveRecord::Type::Text
+      String
+    else
+      # Json type is only supported in Rails 5.2 and above
+      case
+      when Object.const_defined?('ActiveRecord::Type::Json') && klass.is_a?(ActiveRecord::Type::Json)
+        "T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)"
+      when Object.const_defined?('ActiveRecord::Enum::EnumType') && klass.is_a?(ActiveRecord::Enum::EnumType)
+        String
+      # For Postgres UUIDs, they're represented as Strings
+      when Object.const_defined?('ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid') && klass.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid)
+        String
+      else
+        "T.untyped"
+      end
+    end
+  end
+
+  sig { params(attribute: T.any(String, Symbol)).returns(T::Boolean) }
+  def attribute_has_unconditional_presence_validation?(attribute)
+    model_class_srb = model_class
+    model_class_srb < ActiveRecord::Base &&
+    model_class_srb.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

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

@@ -36,10 +36,30 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
     assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : "::#{reflection.klass.name}"
     assoc_type = (belongs_to_and_required?(reflection) || has_one_and_required?(reflection)) ? assoc_class : "T.nilable(#{assoc_class})"
 
+    params = [
+      Parameter.new("*args", type: "T.untyped"),
+      Parameter.new("&block", type: "T.nilable(T.proc.params(object: #{assoc_class}).void)")
+    ]
+
     assoc_module_rbi.create_method(
       assoc_name.to_s,
       return_type: assoc_type,
     )
+    assoc_module_rbi.create_method(
+      "build_#{assoc_name}",
+      parameters: params,
+      return_type: assoc_class,
+    )
+    assoc_module_rbi.create_method(
+      "create_#{assoc_name}",
+      parameters: params,
+      return_type: assoc_class,
+    )
+    assoc_module_rbi.create_method(
+      "create_#{assoc_name}!",
+      parameters: params,
+      return_type: assoc_class,
+    )
     assoc_module_rbi.create_method(
       "#{assoc_name}=",
       parameters: [
@@ -47,6 +67,10 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
       ],
       return_type: nil,
     )
+    assoc_module_rbi.create_method(
+      "reload_#{assoc_name}",
+      return_type: assoc_type,
+    )
   end
 
   sig { params(reflection: T.untyped).returns(T::Boolean) }
@@ -114,9 +138,24 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
       return_type: relation_class,
     )
     unless assoc_should_be_untyped?(reflection)
+      id_type = "T.untyped"
+
+      if reflection.klass.table_exists?
+        # For DB views, the PK column would not exist.
+        id_column = reflection.klass.primary_key
+
+        if id_column
+          id_column_def = reflection.klass.columns_hash[id_column]
+
+          # Normally the id_type is an Integer, but it could be a String if using
+          # UUIDs.
+          id_type = type_for_column_def(id_column_def).to_s if id_column_def
+        end
+      end
+
       assoc_module_rbi.create_method(
         "#{assoc_name.singularize}_ids",
-        return_type: "T::Array[Integer]",
+        return_type: "T::Array[#{id_type}]",
       )
     end
     assoc_module_rbi.create_method(

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

@@ -2,23 +2,6 @@
 require ('sorbet-rails/model_plugins/base')
 class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugins::Base
 
-  class ColumnType < T::Struct
-    extend T::Sig
-
-    const :base_type, T.any(Class, String)
-    const :nilable, T.nilable(T::Boolean)
-    const :array_type,  T.nilable(T::Boolean)
-
-    sig { returns(String) }
-    def to_s
-      type = base_type.to_s
-      # 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
-
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
     columns_hash = @model_class.table_exists? ? @model_class.columns_hash : {}
@@ -41,6 +24,8 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
           column_name,
           column_def,
         )
+      elsif serialization_coder_for_column(column_name)
+        next # handled by the ActiveRecordSerializedAttribute plugin
       else
         column_type = type_for_column_def(column_def)
         attribute_module_rbi.create_method(
@@ -90,18 +75,18 @@ 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}"
-
-        # 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, "%q{#{k}}"] },
-        )
+        root.create_class(model_class_name) do |model_class|
+          # 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)
+          model_class.create_enum_class(
+            config.class_name,
+            enums: t_enum_values.map { |k, v| [v, "%q{#{k}}"] },
+          )
+        end
 
         # define t_enum setter/getter
-        assignable_type = t_enum_type
+        assignable_type = "#{model_class_name}::#{config.class_name}"
         assignable_type = "T.nilable(#{assignable_type})" if nilable_column
         # add directly to model_class_rbi because they are included
         # by sorbet's hidden.rbi
@@ -140,91 +125,6 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     end
   end
 
-  sig { params(column_def: T.untyped).returns(ColumnType) }
-  def type_for_column_def(column_def)
-    cast_type = ActiveRecord::Base.connection.respond_to?(:lookup_cast_type_from_column) ?
-      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,
-        time_zone_aware: time_zone_aware_column?(column_def, cast_type),
-      )
-
-    ColumnType.new(
-      base_type: strict_type,
-      nilable: nilable_column?(column_def),
-      array_type: array_type,
-    )
-  end
-
-  sig do
-    params(
-      klass: Object,
-      time_zone_aware: T::Boolean,
-    ).returns(T.any(String, Class))
-  end
-  def active_record_type_to_sorbet_type(klass, time_zone_aware: false)
-    case klass
-    when ActiveRecord::Type::Boolean
-      "T::Boolean"
-    when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-      time_zone_aware ? ActiveSupport::TimeWithZone : Time
-    when ActiveRecord::Type::Date
-      Date
-    when ActiveRecord::Type::Decimal
-      BigDecimal
-    when ActiveRecord::Type::Float
-      Float
-    when ActiveRecord::Type::BigInteger, ActiveRecord::Type::Integer, ActiveRecord::Type::DecimalWithoutScale, ActiveRecord::Type::UnsignedInteger
-      Integer
-    when ActiveRecord::Type::Binary, ActiveRecord::Type::String, ActiveRecord::Type::Text
-      String
-    else
-      # Json type is only supported in Rails 5.2 and above
-      case
-      when Object.const_defined?('ActiveRecord::Type::Json') && klass.is_a?(ActiveRecord::Type::Json)
-        "T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)"
-      when Object.const_defined?('ActiveRecord::Enum::EnumType') && klass.is_a?(ActiveRecord::Enum::EnumType)
-        String
-      else
-        "T.untyped"
-      end
-    end
-  end
-
-  # True if this column is "time zone aware", which means it'll be converted on
-  # access from its original class (e.g. `DateTime`) to something with better
-  # support for time zones (usually `ActiveSupport::TimeWithZone`)
-  sig do
-    params(column_def: T.untyped, cast_type: T.untyped).returns(T::Boolean)
-  end
-  def time_zone_aware_column?(column_def, cast_type)
-    # this private class method returns true if the attribute should be "time
-    # zone aware"; it takes into account various global and model-specific
-    # configuration options as described here:
-    # https://api.rubyonrails.org/classes/ActiveRecord/Timestamp.html
-    #
-    # although it's private, it's better this than trying to reimplement the "is
-    # this attribute tz aware?" logic ourselves
-    @model_class.send(
-      :create_time_zone_conversion_attribute?,
-      column_def.name,
-      cast_type
-    )
-  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_querying.rb

@@ -74,7 +74,7 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
         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::Enumerable[#{inner_type}]",
+      return_type: "ActiveRecord::Batches::BatchEnumerator",
     )
   end
-end
+end

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

@@ -0,0 +1,68 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveRecordSerializedAttribute < SorbetRails::ModelPlugins::Base
+
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    columns_hash = @model_class.table_exists? ? @model_class.columns_hash : {}
+    return unless any_serialized_columns?(columns_hash)
+
+    serialize_module_name = self.model_module_name('GeneratedSerializedAttributeMethods')
+    serialize_module_rbi = root.create_module(serialize_module_name)
+
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(serialize_module_name)
+
+    columns_hash.sort.each do |column_name, column_def|
+      serialization_coder = serialization_coder_for_column(column_name)
+      next unless serialization_coder
+
+      nilable = nilable_column?(column_def)
+      attr_type = attr_types_for_coder(serialization_coder)
+
+      serialize_module_rbi.create_method(
+        column_name.to_s,
+        return_type: ColumnType.new(base_type: attr_type, nilable: nilable).to_s,
+      )
+
+      serialize_module_rbi.create_method(
+        "#{column_name}=",
+        parameters: [
+          Parameter.new('value', type: ColumnType.new(base_type: attr_type, nilable: nilable).to_s)
+        ],
+        return_type: nil,
+      )
+
+      serialize_module_rbi.create_method(
+        "#{column_name}?",
+        return_type: 'T::Boolean',
+      )
+    end
+  end
+
+  sig { params(columns_hash: T::Hash[String, ActiveRecord::ConnectionAdapters::Column]).returns(T::Boolean) }
+  def any_serialized_columns?(columns_hash)
+    columns_hash.keys.any? do |column_name|
+      !serialization_coder_for_column(column_name).nil?
+    end
+  end
+
+  sig { params(serialization_coder: T.nilable(Class)).returns(String) }
+  def attr_types_for_coder(serialization_coder)
+    case serialization_coder.to_s
+    when 'Hash'
+      # Hash uses YAML.load/YAML.dump, and permits pretty much any kind of Hash key
+      'T::Hash[T.untyped, T.untyped]'
+    when 'Array'
+      # YAML.load/YAML.dump
+      'T::Array[T.untyped]'
+    when 'JSON'
+      # ActiveSupport::JSON.encode/ActiveSupport::JSON.decode
+      # note that Hash keys are Strings since this is JSON
+      'T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[String, T.untyped], Integer, String)'
+    else
+      # unknown uses YAML.load/YAML.dump
+      'T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)'
+    end
+  end
+end