Add support for alias_attribute

lib/sorbet-rails/model_plugins/active_record_attribute.rb

@@ -12,28 +12,38 @@ def generate(root)
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(attribute_module_name)
+
     model_defined_enums = @model_class.defined_enums
+    model_defined_aliases = @model_class.send(:attribute_aliases)
+    column_names = columns_hash.keys
+    aliases_hash = model_class_columns_to_aliases(column_names, model_defined_aliases)
+    attributes_and_aliases_hash = model_class_attributes_and_aliases(columns_hash, aliases_hash)
+
+    attributes_and_aliases_hash.sort.each do |attribute_name, column_def|
+      column_name = column_def.name
 
-    columns_hash.sort.each do |column_name, column_def|
       if model_defined_enums.has_key?(column_name)
         generate_enum_methods(
-          root,
-          model_class_rbi,
-          attribute_module_rbi,
-          model_defined_enums,
-          column_name,
-          column_def,
+          root: root,
+          model_class_rbi: model_class_rbi,
+          attribute_module_rbi: attribute_module_rbi,
+          model_defined_enums: model_defined_enums,
+          attribute_name: attribute_name,
+          column_name: column_name.presence || attribute_name,
+          column_def: 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(
-          column_name.to_s,
+          attribute_name.to_s,
           return_type: column_type.to_s,
         )
+
         attribute_module_rbi.create_method(
-          "#{column_name}=",
+          "#{attribute_name}=",
           parameters: [
             Parameter.new("value", type: value_type_for_attr_writer(column_type))
           ],
@@ -42,29 +52,33 @@ def generate(root)
       end
 
       attribute_module_rbi.create_method(
-        "#{column_name}?",
+        "#{attribute_name}?",
         return_type: "T::Boolean",
       )
     end
   end
 
+  private
+
   sig {
     params(
       root: Parlour::RbiGenerator::Namespace,
       model_class_rbi: Parlour::RbiGenerator::Namespace,
       attribute_module_rbi:  Parlour::RbiGenerator::Namespace,
       model_defined_enums: T::Hash[String, T::Hash[String, T.untyped]],
+      attribute_name: String,
       column_name: String,
       column_def: T.untyped,
     ).void
   }
   def generate_enum_methods(
-    root,
-    model_class_rbi,
-    attribute_module_rbi,
-    model_defined_enums,
-    column_name,
-    column_def
+    root:,
+    model_class_rbi:,
+    attribute_module_rbi:,
+    model_defined_enums:,
+    attribute_name:,
+    column_name:,
+    column_def:
   )
     should_skip_setter_getter = false
     nilable_column = nilable_column?(column_def)
@@ -91,11 +105,11 @@ def generate_enum_methods(
         # add directly to model_class_rbi because they are included
         # by sorbet's hidden.rbi
         model_class_rbi.create_method(
-          "typed_#{column_name}",
+          "typed_#{attribute_name}",
           return_type: assignable_type,
         )
         model_class_rbi.create_method(
-          "typed_#{column_name}=",
+          "typed_#{attribute_name}=",
           parameters: [
             Parameter.new("value", type: assignable_type)
           ],
@@ -112,11 +126,11 @@ def generate_enum_methods(
       return_type = "T.nilable(#{return_type})" if nilable_column
 
       attribute_module_rbi.create_method(
-        column_name.to_s,
+        attribute_name.to_s,
         return_type: return_type,
       )
       attribute_module_rbi.create_method(
-        "#{column_name}=",
+        "#{attribute_name}=",
         parameters: [
           Parameter.new("value", type: assignable_type)
         ],

lib/sorbet-rails/model_plugins/active_record_serialized_attribute.rb

@@ -13,28 +13,34 @@ def generate(root)
     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|
+    model_defined_aliases = @model_class.send(:attribute_aliases)
+    column_names = columns_hash.keys
+    aliases_hash = model_class_columns_to_aliases(column_names, model_defined_aliases)
+    attributes_and_aliases_hash = model_class_attributes_and_aliases(columns_hash, aliases_hash)
+
+    attributes_and_aliases_hash.sort.each do |attribute_name, column_def|
+      column_name = column_def.name || attribute_name
       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,
+        attribute_name.to_s,
         return_type: ColumnType.new(base_type: attr_type, nilable: nilable).to_s,
       )
 
       serialize_module_rbi.create_method(
-        "#{column_name}=",
+        "#{attribute_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}?",
+        "#{attribute_name}?",
         return_type: 'T::Boolean',
       )
     end

lib/sorbet-rails/model_plugins/base.rb

@@ -30,6 +30,8 @@ def initialize(model_class, available_classes)
       @available_classes = T.let(available_classes, T::Set[String])
     end
 
+    private
+
     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)
@@ -44,5 +46,43 @@ def serialization_coder_for_column(column_name)
         Object
       end
     end
+
+    sig {
+      params(column_names: T::Array[String], aliases: T::Hash[String, String])
+        .returns(T::Hash[String, T::Array[String]])
+    }
+    def model_class_columns_to_aliases(column_names, aliases)
+      column_names.each_with_object({}) do |column_name, columns_to_aliases|
+        direct_aliases = aliases.select do |_alias_name, attribute_name|
+          attribute_name == column_name
+        end.keys
+        all_aliases = direct_aliases.flat_map do |direct_alias_name|
+          recursive_keys_for_value(aliases, direct_alias_name).push(direct_alias_name)
+        end
+
+        columns_to_aliases[column_name] = all_aliases unless all_aliases.empty?
+      end
+    end
+
+    sig { params(hash: T::Hash[String, String], initial_value: String).returns(T::Array[String]) }
+    def recursive_keys_for_value(hash, initial_value)
+      initial_keys = hash.select { |_key, value| value == initial_value }.keys
+      initial_keys.flat_map { |key| [key].concat(recursive_keys_for_value(hash, key)) }
+    end
+
+    sig {
+      params(
+        columns_hash: T::Hash[String, T.untyped],
+        aliases_hash: T::Hash[String, T::Array[String]],
+      ).returns(T::Hash[String, T.untyped])
+    }
+    def model_class_attributes_and_aliases(columns_hash, aliases_hash)
+      columns_hash
+        .each_with_object({}) do |(column_name, column_def), attributes_and_aliases|
+          [column_name].concat(aliases_hash[column_name] || []).each do |attribute_name|
+            attributes_and_aliases[attribute_name] = column_def
+          end
+        end
+    end
   end
 end

spec/generators/rails-template.rb

@@ -92,6 +92,9 @@ class SpellBook < ApplicationRecord
         dark_art: 999,
       }
 
+      alias_attribute :title, :name
+      alias_attribute :book_category, :book_type
+
       scope :recent, -> { where('created_at > ?', 1.month.ago) }
     end
   RUBY
@@ -179,6 +182,8 @@ class Professor; end
       serialize :pets, Array
       serialize :patronus_characteristics, JSON
 
+      alias_attribute :ordinary_wizarding_level_results, :owl_results
+
       has_one :wand
       has_many :spell_books
       # habtm which is optional at the db level

spec/generators/sorbet_test_cases.rb

@@ -8,6 +8,17 @@
 # -- model columns
 T.assert_type!(wizard.name, T.nilable(String))
 
+spell_book = wizard.spell_books.first!
+T.assert_type!(spell_book, SpellBook)
+
+# -- alias attributes
+T.assert_type!(spell_book.title, String) # standard alias attribute
+T.assert_type!(spell_book.book_category, String) # enum alias attribute
+T.assert_type!(
+  wizard.ordinary_wizarding_level_results, # serialized alias attribute
+  T.nilable(T::Hash[T.untyped, T.untyped])
+)
+
 # -- time/date columns
 T.assert_type!(wizard.created_at, ActiveSupport::TimeWithZone)
 T.assert_type!(wand.broken_at, T.nilable(Time))
@@ -157,7 +168,6 @@
 T.assert_type!(Wizard.all.empty?, T::Boolean)
 
 # Finder methods -- CollectionProxy
-spell_book = wizard.spell_books.first!
 spell_books = wizard.spell_books
 T.assert_type!(spell_books.exists?(name: 'Fantastic Beasts'), T::Boolean)
 T.assert_type!(spell_books.find(spell_book.id), SpellBook)

spec/support/v5.2/app/models/spell_book.rb

@@ -14,5 +14,8 @@ class SpellBook < ApplicationRecord
     dark_art: 999,
   }
 
+  alias_attribute :title, :name
+  alias_attribute :book_category, :book_type
+
   scope :recent, -> { where('created_at > ?', 1.month.ago) }
 end

spec/support/v5.2/app/models/wizard.rb

@@ -52,6 +52,8 @@ class Professor; end
   serialize :pets, Array
   serialize :patronus_characteristics, JSON
 
+  alias_attribute :ordinary_wizarding_level_results, :owl_results
+
   has_one :wand
   has_many :spell_books
   # habtm which is optional at the db level

spec/support/v5.2/sorbet_test_cases.rb

@@ -8,6 +8,17 @@
 # -- model columns
 T.assert_type!(wizard.name, T.nilable(String))
 
+spell_book = wizard.spell_books.first!
+T.assert_type!(spell_book, SpellBook)
+
+# -- alias attributes
+T.assert_type!(spell_book.title, String) # standard alias attribute
+T.assert_type!(spell_book.book_category, String) # enum alias attribute
+T.assert_type!(
+  wizard.ordinary_wizarding_level_results, # serialized alias attribute
+  T.nilable(T::Hash[T.untyped, T.untyped])
+)
+
 # -- time/date columns
 T.assert_type!(wizard.created_at, ActiveSupport::TimeWithZone)
 T.assert_type!(wand.broken_at, T.nilable(Time))
@@ -161,7 +172,6 @@
 T.assert_type!(Wizard.all.empty?, T::Boolean)
 
 # Finder methods -- CollectionProxy
-spell_book = wizard.spell_books.first!
 spell_books = wizard.spell_books
 T.assert_type!(spell_books.exists?(name: 'Fantastic Beasts'), T::Boolean)
 T.assert_type!(spell_books.find(spell_book.id), SpellBook)

spec/support/v6.0/app/models/spell_book.rb

@@ -14,5 +14,8 @@ class SpellBook < ApplicationRecord
     dark_art: 999,
   }
 
+  alias_attribute :title, :name
+  alias_attribute :book_category, :book_type
+
   scope :recent, -> { where('created_at > ?', 1.month.ago) }
 end

spec/support/v6.0/app/models/wizard.rb

@@ -52,6 +52,8 @@ class Professor; end
   serialize :pets, Array
   serialize :patronus_characteristics, JSON
 
+  alias_attribute :ordinary_wizarding_level_results, :owl_results
+
   has_one :wand
   has_many :spell_books
   # habtm which is optional at the db level

spec/support/v6.0/sorbet_test_cases.rb

@@ -8,6 +8,17 @@
 # -- model columns
 T.assert_type!(wizard.name, T.nilable(String))
 
+spell_book = wizard.spell_books.first!
+T.assert_type!(spell_book, SpellBook)
+
+# -- alias attributes
+T.assert_type!(spell_book.title, String) # standard alias attribute
+T.assert_type!(spell_book.book_category, String) # enum alias attribute
+T.assert_type!(
+  wizard.ordinary_wizarding_level_results, # serialized alias attribute
+  T.nilable(T::Hash[T.untyped, T.untyped])
+)
+
 # -- time/date columns
 T.assert_type!(wizard.created_at, ActiveSupport::TimeWithZone)
 T.assert_type!(wand.broken_at, T.nilable(Time))
@@ -161,7 +172,6 @@
 T.assert_type!(Wizard.all.empty?, T::Boolean)
 
 # Finder methods -- CollectionProxy
-spell_book = wizard.spell_books.first!
 spell_books = wizard.spell_books
 T.assert_type!(spell_books.exists?(name: 'Fantastic Beasts'), T::Boolean)
 T.assert_type!(spell_books.find(spell_book.id), SpellBook)

spec/support/v6.1/app/models/spell_book.rb

@@ -14,5 +14,8 @@ class SpellBook < ApplicationRecord
     dark_art: 999,
   }
 
+  alias_attribute :title, :name
+  alias_attribute :book_category, :book_type
+
   scope :recent, -> { where('created_at > ?', 1.month.ago) }
 end

spec/support/v6.1/app/models/wizard.rb

@@ -52,6 +52,8 @@ class Professor; end
   serialize :pets, Array
   serialize :patronus_characteristics, JSON
 
+  alias_attribute :ordinary_wizarding_level_results, :owl_results
+
   has_one :wand
   has_many :spell_books
   # habtm which is optional at the db level

spec/support/v6.1/sorbet_test_cases.rb

@@ -8,6 +8,17 @@
 # -- model columns
 T.assert_type!(wizard.name, T.nilable(String))
 
+spell_book = wizard.spell_books.first!
+T.assert_type!(spell_book, SpellBook)
+
+# -- alias attributes
+T.assert_type!(spell_book.title, String) # standard alias attribute
+T.assert_type!(spell_book.book_category, String) # enum alias attribute
+T.assert_type!(
+  wizard.ordinary_wizarding_level_results, # serialized alias attribute
+  T.nilable(T::Hash[T.untyped, T.untyped])
+)
+
 # -- time/date columns
 T.assert_type!(wizard.created_at, ActiveSupport::TimeWithZone)
 T.assert_type!(wand.broken_at, T.nilable(Time))
@@ -163,7 +174,6 @@
 T.assert_type!(Wizard.all.empty?, T::Boolean)
 
 # Finder methods -- CollectionProxy
-spell_book = wizard.spell_books.first!
 spell_books = wizard.spell_books
 T.assert_type!(spell_books.exists?(name: 'Fantastic Beasts'), T::Boolean)
 T.assert_type!(spell_books.find(spell_book.id), SpellBook)

spec/support/v7.0/app/models/spell_book.rb

@@ -14,5 +14,8 @@ class SpellBook < ApplicationRecord
     dark_art: 999,
   }
 
+  alias_attribute :title, :name
+  alias_attribute :book_category, :book_type
+
   scope :recent, -> { where('created_at > ?', 1.month.ago) }
 end