sorbet-rails 0.5.9.1 → 0.6.0

data/lib/sorbet-rails.rb

@@ -6,5 +6,6 @@ module SorbetRails
     require 'sorbet-rails/type_assert/type_assert'
     require 'sorbet-rails/custom_types/integer_string'
     require 'sorbet-rails/custom_types/boolean_string'
+    require 'sorbet-rails/typed_params'
   end
 end

data/lib/sorbet-rails/config.rb

@@ -48,7 +48,6 @@ module SorbetRails
         :active_record_attribute,
         :active_record_assoc,
         :active_record_finder_methods,
-        :active_record_factory_methods,
         :custom_finder_methods,
         :enumerable_collections,
       ]

data/lib/sorbet-rails/gem_plugins/elastic_search_plugin.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 class ElasticSearchPlugin < SorbetRails::ModelPlugins::Base
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)

data/lib/sorbet-rails/gem_plugins/friendly_id_plugin.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 class FriendlyIdPlugin < SorbetRails::ModelPlugins::Base
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)

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

@@ -70,11 +70,11 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
 
     if rails_required_config && !db_required_config
       puts "Warning: belongs_to association #{reflection.name} is required at the application
-        level but **nullable** at the DB level. Add a constraint at the DB level
+        level but **nullable** at the DB level.\n Add a constraint at the DB level
         (using `null: false` and foreign key constraint) to ensure it is enforced.".squish!
     elsif !rails_required_config && db_required_config
-      puts "Warning: belongs_to association #{reflection.name} is specified as not-null at the
-        DB level but **not required** at the application level. Add a constraint at the app level
+      puts "Note: belongs_to association #{reflection.name} is specified as not-null at the
+        DB level but **optional** at the application level.\n Add a constraint at the app level
         (using `optional: false`) as a validation hint to Rails.".squish!
     end
 

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

@@ -13,25 +13,17 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
 
     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
 
     columns_hash.sort.each do |column_name, column_def|
-      if @model_class.defined_enums.has_key?(column_name)
-        # enum attribute is treated differently
-        assignable_type = "T.any(Integer, String, Symbol)"
-        assignable_type = "T.nilable(#{assignable_type})" if column_def.null
-        return_type = "String"
-        return_type = "T.nilable(#{return_type})" if column_def.null
-
-        attribute_module_rbi.create_method(
-          column_name.to_s,
-          return_type: return_type,
-        )
-        attribute_module_rbi.create_method(
-          "#{column_name}=",
-          parameters: [
-            Parameter.new("value", type: assignable_type)
-          ],
-          return_type: nil,
+      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,
         )
       else
         column_type = type_for_column_def(column_def)
@@ -55,6 +47,82 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     end
   end
 
+  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]],
+      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
+  )
+    should_skip_setter_getter = false
+
+    if @model_class.is_a?(::ActiveRecord::Enum)
+      config = @model_class.typed_enum_reflections[column_name]
+      if config.present?
+        # 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, "'#{k}'"] },
+        )
+
+        # define t_enum setter/getter
+        assignable_type = t_enum_type
+        assignable_type = "T.nilable(#{assignable_type})" if column_def.null
+        # add directly to model_class_rbi because they are included
+        # by sorbet's hidden.rbi
+        model_class_rbi.create_method(
+          "typed_#{column_name}",
+          return_type: assignable_type,
+        )
+        model_class_rbi.create_method(
+          "typed_#{column_name}=",
+          parameters: [
+            Parameter.new("value", type: assignable_type)
+          ],
+          return_type: nil,
+        )
+      end
+    end
+
+    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
+      return_type = "String"
+      return_type = "T.nilable(#{return_type})" if column_def.null
+
+      attribute_module_rbi.create_method(
+        column_name.to_s,
+        return_type: return_type,
+      )
+      attribute_module_rbi.create_method(
+        "#{column_name}=",
+        parameters: [
+          Parameter.new("value", type: assignable_type)
+        ],
+        return_type: nil,
+      )
+    end
+  end
+
   sig { params(column_def: T.untyped).returns(T.any(String, Class)) }
   def type_for_column_def(column_def)
     cast_type = ActiveRecord::Base.connection.respond_to?(:lookup_cast_type_from_column) ?

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

@@ -14,8 +14,6 @@ class SorbetRails::ModelPlugins::ActiveRecordEnum < SorbetRails::ModelPlugins::B
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(enum_module_name)
 
-    enum_calls = ActiveRecordOverrides.instance.enum_calls[self.model_class_name]
-
     # TODO: add any method for signature verification?
     model_class.defined_enums.sort.each do |enum_name, enum_hash|
       value_type = enum_hash.values.map { |v| v.is_a?(Integer) ? 'Integer' : v.class.name }.uniq

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

@@ -5,7 +5,7 @@ class SorbetRails::ModelPlugins::ActiveRecordFinderMethods < SorbetRails::ModelP
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
     model_class_rbi = root.create_class(self.model_class_name)
-    create_finder_methods_for(model_class_rbi, class_method: true)
+    create_finder_methods_for(model_class_rbi, class_method: true, include_methods_that_return_self: false)
 
     model_relation_class_rbi = root.create_class(self.model_relation_class_name)
     create_finder_methods_for(model_relation_class_rbi, class_method: false, include_methods_that_return_self: false)
@@ -47,27 +47,64 @@ class SorbetRails::ModelPlugins::ActiveRecordFinderMethods < SorbetRails::ModelP
         return_type: self.model_class_name,
         class_method: class_method
       )
+      class_rbi.create_method(
+        "find_or_initialize_by",
+        parameters: [
+          Parameter.new("attributes", type: "T.untyped") ,
+          Parameter.new(
+            "&block",
+            type: "T.nilable(T.proc.params(object: #{self.model_class_name}).void)",
+          ),
+        ],
+        return_type: self.model_class_name,
+        class_method: class_method
+      )
+      class_rbi.create_method(
+        "find_or_create_by",
+        parameters: [
+          Parameter.new("attributes", type: "T.untyped") ,
+          Parameter.new(
+            "&block",
+            type: "T.nilable(T.proc.params(object: #{self.model_class_name}).void)"
+          ),
+        ],
+        return_type: self.model_class_name,
+        class_method: class_method
+      )
+      class_rbi.create_method(
+        "find_or_create_by!",
+        parameters: [
+          Parameter.new("attributes", type: "T.untyped") ,
+          Parameter.new(
+            "&block",
+            type: "T.nilable(T.proc.params(object: #{self.model_class_name}).void)",
+          ),
+        ],
+        return_type: self.model_class_name,
+        class_method: class_method
+      )
 
       ["first", "second", "third", "third_to_last", "second_to_last", "last"].
         each do |method_name|
           create_finder_method_pair(class_rbi, method_name, class_method)
         end
+    end
 
-      # Checker methods
+    # Checker methods
+    class_rbi.create_method(
+      "exists?",
+      parameters: [ Parameter.new("conditions", type: "T.untyped", default: "nil") ],
+      return_type: "T::Boolean",
+      class_method: class_method,
+    )
+
+    ["any?", "many?", "none?", "one?"].each do |method_name|
       class_rbi.create_method(
-        "exists?",
-        parameters: [ Parameter.new("conditions", type: "T.untyped", default: "nil") ],
+        method_name,
+        parameters: [ Parameter.new("*args", type: "T.untyped") ],
         return_type: "T::Boolean",
         class_method: class_method,
       )
-      ["any?", "many?", "none?", "one?"].each do |method_name|
-        class_rbi.create_method(
-          method_name,
-          parameters: [ Parameter.new("*args", type: "T.untyped") ],
-          return_type: "T::Boolean",
-          class_method: class_method,
-        )
-      end
     end
   end
 

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

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 require ('sorbet-rails/model_plugins/base')
 class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugins::Base
 

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

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 require ('sorbet-rails/model_plugins/base')
 class SorbetRails::ModelPlugins::ActiveStorageMethods < SorbetRails::ModelPlugins::Base
   sig { params(model_class: T.class_of(ActiveRecord::Base), available_classes: T::Set[String]).void }

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

@@ -7,7 +7,6 @@ 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/active_record_factory_methods')
 require('sorbet-rails/model_plugins/custom_finder_methods')
 require('sorbet-rails/model_plugins/enumerable_collections')
 require('sorbet-rails/model_plugins/active_storage_methods')
@@ -55,8 +54,6 @@ module SorbetRails::ModelPlugins
       ActiveRecordAssoc
     when :active_record_finder_methods
       ActiveRecordFinderMethods
-    when :active_record_factory_methods
-      ActiveRecordFactoryMethods
     when :custom_finder_methods
       CustomFinderMethods
     when :enumerable_collections

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

@@ -17,8 +17,10 @@ class ActiveRecordOverrides
     # modeling the logic in
     # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/enum.rb#L152
     kwargs.each do |name, values|
-      next if [:_prefix, :_suffix, :_scopes].include?(name)
-      @enum_calls[class_name][name] = kwargs
+      next if ::ActiveRecord::Enum::SR_ENUM_KEYWORDS.include?(name)
+
+      # calling dup is required, because Rails internally mutates `kwargs` (the args you passed to `enum`)
+      @enum_calls[class_name][name] = kwargs.dup
     end
   end
 
@@ -31,11 +33,160 @@ class ActiveRecordOverrides
   end
 end
 
+class SorbetRails::TypedEnumConfig < T::Struct
+  # set the method to be true or false
+  const :strict_mode, T::Boolean
+  const :class_name, String
+end
+
 module ::ActiveRecord::Enum
+  extend T::Sig
+  include Kernel
+
   alias old_enum enum
 
-  def enum(*args, **kwargs)
-    ActiveRecordOverrides.instance.store_enum_call(self, kwargs)
-    old_enum(*args, **kwargs)
+  SR_ENUM_KEYWORDS = [
+    # keywords from https://github.com/rails/rails/blob/master/activerecord/lib/active_record/enum.rb
+    :_prefix,
+    :_suffix,
+    :_scopes
+  ]
+
+  sig { params(definitions: T::Hash[Symbol, T.untyped]).void }
+  def _define_enum(definitions)
+    ActiveRecordOverrides.instance.store_enum_call(self, definitions)
+    old_enum(definitions)
+  end
+
+  sig { params(definitions: T::Hash[Symbol, T.untyped]).void }
+  def enum(definitions)
+    _define_enum(definitions)
+    definitions.each do |enum_name, values|
+      begin
+        # skip irrelevant keywords
+        next if SR_ENUM_KEYWORDS.include?(enum_name)
+        _define_typed_enum(enum_name, extract_enum_values(values))
+      rescue ArgumentError, ConflictTypedEnumNameError, TypeError => ex
+        # known errors
+        # do nothing if we cannot define t_enum
+        puts "warning: #{ex.message}"
+      rescue => ex
+        # rescue any other kind of error to unblock the application
+        # can be disabled in development
+        puts "warning: #{ex.message}"
+        # raise ex
+      end
+    end
+  end
+
+  sig { params(definitions: T::Hash[Symbol, T.untyped]).void }
+  def typed_enum(definitions)
+    enum_names = definitions.keys - SR_ENUM_KEYWORDS
+
+    if enum_names.size != 1
+      raise MultipleEnumsDefinedError.new(
+        "typed_enum only supports 1 enum defined at a time,
+        given #{enum_names.count}: #{enum_names.join(', ')}".squish!
+      )
+    end
+
+    enum_name = enum_names[0]
+
+    _define_enum(definitions)
+    _define_typed_enum(
+      T.must(enum_name),
+      extract_enum_values(definitions[enum_name]),
+      strict_mode: true,
+    )
+  end
+
+  # this config is for sorbet-rails to inflect on the settings
+  sig { returns(T::Hash[String, SorbetRails::TypedEnumConfig]) }
+  def typed_enum_reflections
+    @typed_enum_reflections ||= {}
   end
+
+  sig {
+    params(
+      enum_name: Symbol,
+      enum_values: T::Array[Symbol],
+      strict_mode: T::Boolean,
+    ).
+    void
+  }
+  def _define_typed_enum(
+    enum_name,
+    enum_values,
+    strict_mode: false
+  )
+    enum_klass_name = enum_name.to_s.camelize
+
+    # we don't need to use the actual enum value
+    typed_enum_values = gen_typed_enum_values(enum_values.map(&:to_s))
+
+    # create dynamic T::Enum definition
+    if const_defined?(enum_klass_name)
+      # append Enum to avoid conflict
+      enum_klass_name = "#{enum_klass_name}Enum"
+      if const_defined?(enum_klass_name)
+        raise ConflictTypedEnumNameError.new(
+          "Unable to define enum class #{enum_klass_name} because
+          it's already defined".squish!
+        )
+      end
+    end
+    enum_klass = Class.new(T::Enum) do
+      enums do
+        typed_enum_values.each do |enum_key_name, typed_enum_value|
+          const_set(typed_enum_value, new(enum_key_name))
+        end
+      end
+    end
+    const_set(enum_klass_name, enum_klass)
+
+    # create t_enum getter to get T::Enum value
+    # assuming there shouldn't be any conflict
+    typed_enum_getter_name = "typed_#{enum_name}"
+    detect_enum_conflict!(enum_name, typed_enum_getter_name)
+    define_method(typed_enum_getter_name) do
+      T.unsafe(enum_klass).try_deserialize(send(enum_name))
+    end
+
+    # override the setter to accept T::Enum values
+    enum_setter_name = "#{enum_name}="
+    typed_enum_setter_name = "typed_#{enum_name}="
+    detect_enum_conflict!(enum_name, typed_enum_setter_name)
+    define_method(typed_enum_setter_name) do |value|
+      send(enum_setter_name, value&.serialize)
+    end
+
+    # add to the config for RBI generation only if it works
+    typed_enum_reflections[enum_name.to_s] = SorbetRails::TypedEnumConfig.new(
+      strict_mode: strict_mode || false,
+      class_name: enum_klass_name,
+    )
+  end
+
+  sig { params(enum_values: T::Array[String]).returns(T::Hash[String, String]) }
+  def gen_typed_enum_values(enum_values)
+    Hash[enum_values.map do |val|
+      [val, val.to_s.gsub(/[^0-9a-z_]/i, '').camelize]
+    end]
+  end
+
+  sig {
+    params(
+      enum_def: T.any(
+        T::Array[T.untyped],
+        T::Hash[T.untyped, T.untyped],
+        ActiveSupport::HashWithIndifferentAccess
+      ),
+    ).returns(T::Array[Symbol])
+  }
+  def extract_enum_values(enum_def)
+    enum_def.is_a?(Array) ? enum_def.map(&:to_sym) : enum_def.keys.map(&:to_sym)
+  end
+
+  class MultipleEnumsDefinedError < StandardError; end
+  class ConflictTypedEnumNameError < StandardError; end
 end