sorbet-rails 0.6.2 → 0.6.3

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
@@ -82,6 +83,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 +91,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 +123,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 +147,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 +160,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 +221,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/base.rb

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

data/lib/sorbet-rails/model_utils.rb

@@ -5,27 +5,36 @@ 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) }
@@ -46,7 +55,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) }

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

@@ -1,5 +1,6 @@
 # typed: false
 require 'sorbet-runtime'
+require('sorbet-rails/deprecation.rb')
 
 module SorbetRails::CustomParamsMethods
   include Kernel
@@ -16,6 +17,11 @@ module SorbetRails::CustomParamsMethods
     returns(T.type_parameter(:U))
   }
   def require_typed(key, ta)
+    SorbetRails::TypeAssertDeprecation.deprecation_warning(
+      :require_typed,
+      'Use TypedParams with a T::Struct represents the type of each parameters.'
+    )
+
     val = require(key)
     ta.assert(val)
   rescue TypeError
@@ -35,6 +41,11 @@ module SorbetRails::CustomParamsMethods
     returns(T.type_parameter(:U))
   }
   def fetch_typed(key, ta, *args)
+    SorbetRails::TypeAssertDeprecation.deprecation_warning(
+      :fetch_typed,
+      'Use TypedParams with a T::Struct represents the type of each parameters.'
+    )
+
     val = fetch(key, *args)
     ta.assert(val)
   rescue TypeError

data/lib/sorbet-rails/tasks/rails_rbi.rake

@@ -1,3 +1,4 @@
+require("sorbet-rails/active_record_rbi_formatter")
 require("sorbet-rails/model_rbi_formatter")
 require("sorbet-rails/routes_rbi_formatter")
 require("sorbet-rails/helper_rbi_formatter")
@@ -39,9 +40,23 @@ namespace :rails_rbi do
     copy_bundled_rbi('type_assert.rbi')
     copy_bundled_rbi('parameters.rbi')
     copy_bundled_rbi('pluck_to_tstruct.rbi')
-    copy_bundled_rbi('active_record_relation.rbi')
-    copy_bundled_rbi('active_record_base.rbi')
     copy_bundled_rbi('typed_params.rbi')
+
+    # These files were previously bundled_rbi but are now generated so this
+    # is needed for backwards compatibility with anyone using `rails_rbi:custom`
+    Rake::Task['rails_rbi:active_record'].invoke
+  end
+
+  desc "Generate rbis for rails mailers"
+  task :active_record, [:root_dir] => :environment do |t, args|
+    formatter = SorbetRails::ActiveRecordRbiFormatter.new
+    FileUtils.mkdir_p(Rails.root.join("sorbet", "rails-rbi"))
+
+    file_path = Rails.root.join("sorbet", "rails-rbi", "active_record_base.rbi")
+    File.write(file_path, formatter.generate_active_record_base_rbi)
+
+    file_path = Rails.root.join("sorbet", "rails-rbi", "active_record_relation.rbi")
+    File.write(file_path, formatter.generate_active_record_relation_rbi)
   end
 
   desc "Generate rbis for rails models. Pass models name to regenerate rbi for only the given models."
@@ -133,12 +148,13 @@ namespace :rails_rbi do
   def generate_rbis_for_models(model_classes, available_classes)
     available_class_names = Set.new(available_classes.map { |c| c.name })
     formatted = model_classes.map do |model_class|
+      model_class_name = model_class.to_s
       begin
         formatter = SorbetRails::ModelRbiFormatter.new(model_class, available_class_names)
-        [model_class.name, formatter.generate_rbi]
+        [model_class_name, formatter.generate_rbi]
       rescue StandardError, NotImplementedError => ex
         puts "---"
-        puts "Error when handling model #{model_class.name}: #{ex}"
+        puts "Error when handling model #{model_class_name}: #{ex}"
         nil
       end
     end

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.6.2"
+  s.version       = "0.6.3"
   s.date          = %q{2019-04-18}
   s.summary       = %q{Set of tools to make Sorbet work with Rails seamlessly.}
   s.authors       = ["Chan Zuckerberg Initiative"]
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'parlour', '~> 2.0'
   s.add_dependency 'sorbet-runtime', '>= 0.5'
-  s.add_dependency 'sorbet-coerce', '>= 0.2.4'
+  s.add_dependency 'sorbet-coerce', '>= 0.2.6'
   s.add_dependency 'method_source', '>= 0.9.2'
   s.add_dependency 'parser', '>= 2.7'
 

data/spec/active_record_rbi_formatter_spec.rb

@@ -0,0 +1,24 @@
+require 'rails_helper'
+require 'sorbet-rails/active_record_rbi_formatter'
+
+RSpec.describe SorbetRails::ActiveRecordRbiFormatter do
+  describe 'generate_active_record_base_rbi' do
+    it 'returns the expected rbi' do
+      formatter = SorbetRails::ActiveRecordRbiFormatter.new
+      expect_match_file(
+        formatter.generate_active_record_base_rbi,
+        'expected_active_record_base.rbi'
+      )
+    end
+  end
+
+  describe 'generate_active_record_relation_rbi' do
+    it 'returns the expected rbi' do
+      formatter = SorbetRails::ActiveRecordRbiFormatter.new
+      expect_match_file(
+        formatter.generate_active_record_relation_rbi,
+        'expected_active_record_relation.rbi'
+      )
+    end
+  end
+end

data/spec/generators/rails-template.rb

@@ -51,7 +51,7 @@ def create_lib
         model_class_rbi.create_method(
           'mythicals',
           class_method: true,
-          return_type: "T::Array[#{@model_class.name}]",
+          return_type: "T::Array[#{model_class_name}]",
         )
       end
     end
@@ -83,6 +83,9 @@ def create_models
       # simulate when belongs_to is optional by default, but it is enforced at the DB level
       belongs_to :wizard, optional: true
 
+      # habtm enforced at the DB level
+      has_and_belongs_to_many :spells
+
       enum book_type: {
         unclassified: 0,
         biology: 1,
@@ -129,6 +132,8 @@ def create_models
   file "app/models/wizard.rb", <<~RUBY
     class Wizard < ApplicationRecord
       validates :name, length: { minimum: 5 }, presence: true
+      # simulate conditional validation
+      validates :parent_email, presence: true, if: -> { false }
 
       typed_enum house: {
         Gryffindor: 0,
@@ -146,6 +151,7 @@ def create_models
         "Pomona Sprout": 2,
         "Filius Flitwick": 3,
         "Hagrid": 4,
+        "Alastor 'Mad-Eye' Moody": 5,
       }
 
       typed_enum broom: {
@@ -174,6 +180,8 @@ def create_models
 
       has_one :wand
       has_many :spell_books
+      # habtm which is optional at the db level
+      has_and_belongs_to_many :subjects
 
       # simulate when belongs_to is optional by default
       belongs_to :school, optional: true
@@ -212,8 +220,35 @@ def create_models
 
   file "app/models/school.rb", <<~RUBY
     class School < ApplicationRecord
+      has_one :headmaster
+      validates :headmaster, presence: true
+    end
+  RUBY
+
+  file "app/models/subject.rb", <<~RUBY
+    class Subject < ApplicationRecord
+      # habtm which is optional at the db level
+      has_and_belongs_to_many :wizards
+    end
+  RUBY
+
+  file "app/models/spell.rb", <<~RUBY
+    class Spell < ApplicationRecord
+      # habtm enforced at the DB level
+      has_and_belongs_to_many :spell_books
+    end
+  RUBY
+
+  file "app/models/headmaster.rb", <<~RUBY
+    class Headmaster < ApplicationRecord
+      belongs_to :school, required: false
+      belongs_to :wizard, optional: true
+
+      validates :school, presence: true
+      validates :wizard_id, presence: true
     end
   RUBY
+
 end
 
 def create_migrations
@@ -328,6 +363,58 @@ def create_migrations
       end
     end
   RUBY
+
+  file "db/migrate/20190620000010_add_subject.rb", <<~RUBY
+    class AddSubject < #{migration_superclass}
+      def change
+        create_table :subjects do |t|
+          t.string :name
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000011_add_subjects_wizards.rb", <<~RUBY
+    class AddSubjectsWizards < #{migration_superclass}
+      def change
+        create_join_table :subjects, :wizards, column_options: { null: true } do |t|
+          t.index [:subject_id, :wizard_id]
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000012_add_spell.rb", <<~RUBY
+    class AddSpell < #{migration_superclass}
+      def change
+        create_table :spells do |t|
+          t.string :name
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000013_add_spells_spell_books.rb", <<~RUBY
+    class AddSpellsSpellBooks < #{migration_superclass}
+      def change
+        create_join_table :spells, :spell_books do |t|
+          t.index [:spell_id, :spell_book_id]
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000014_create_headmasters.rb", <<~RUBY
+    class CreateHeadmasters < #{migration_superclass}
+      def change
+        create_table :headmasters do |t|
+          t.references :school
+          t.references :wizard
+        end
+      end
+    end
+  RUBY
+
 end
 
 def create_mailers