sorbet-rails 0.7.3 → 0.7.33

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

@@ -0,0 +1,55 @@
+# typed: false
+class AasmPlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless @model_class.include?(::AASM)
+
+    model_rbi = root.create_class(
+      model_class_name
+    )
+
+    aasm_events = @model_class.aasm.events.map(&:name)
+    aasm_states = @model_class.aasm.states.map(&:name)
+
+    # If you have an event like :bazify, you get these methods:
+    # - `may_bazify?`
+    # - `bazify`
+    # - `bazify!`
+    # - `bazify_without_validation!`
+    aasm_events.each do |event|
+      model_rbi.create_method(
+        "may_#{event}?",
+        return_type: 'T::Boolean'
+      )
+
+      model_rbi.create_method(
+        event.to_s,
+        return_type: 'T::Boolean'
+      )
+
+      model_rbi.create_method(
+        "#{event}!",
+        return_type: 'T::Boolean'
+      )
+
+      model_rbi.create_method(
+        "#{event}_without_validation!",
+        return_type: 'T::Boolean'
+      )
+    end
+
+    # - If you have a state like :baz, you get:
+    # - a method `baz?`
+    # - a constant `STATE_BAZ`
+    aasm_states.each do |state|
+      model_rbi.create_method(
+        "#{state}?",
+        return_type: 'T::Boolean'
+      )
+
+      root.create_module(
+        "#{model_class_name}::STATE_#{state.to_s.upcase}"
+      )
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# typed: false
+class AttrJsonPlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless @model_class.include?(::AttrJson::Record)
+
+    # Module for instance methods
+    obj_custom_module_name = self.model_module_name("GeneratedAttrJsonMethods")
+    obj_custom_module_rbi = root.create_module(obj_custom_module_name)
+
+    # Module for class methods
+    klass_custom_module_name = self.model_module_name("GeneratedAttrJsonClassMethods")
+    klass_custom_module_rbi = root.create_module(klass_custom_module_name)
+
+    # here we re-create the model class!
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(obj_custom_module_name)
+    model_class_rbi.create_extend(klass_custom_module_name)
+
+    # then create custom methods, constants, etc. for this module.
+    add_class_methods(klass_custom_module_rbi)
+
+    @model_class.attr_json_registry.definitions.each do |definition|
+      add_methods_for_attributes(definition, obj_custom_module_rbi)
+    end
+
+    if @model_class.include?(::AttrJson::Record::Dirty)
+      obj_custom_module_rbi.create_method(
+        'attr_json_changes',
+        returns: 'AttrJson::Record::Dirty::Implementation'
+      )
+    end
+  end
+
+  private
+
+  sig { params(custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_class_methods(custom_module_rbi)
+    custom_module_rbi.create_method(
+      'attr_json_config',
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'new_values',
+          type: 'T.nilable(T::Hash[Symbol, T.untyped])'
+        )
+      ],
+      returns: 'T::Hash[Symbol, T.untyped]'
+    )
+
+    custom_module_rbi.create_method(
+      'attr_json',
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'name',
+          type: 'T.any(Symbol, String)'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'type',
+          type: 'T.any(Symbol, ActiveModel::Type::Value)'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          '**options',
+          type: 'T.untyped'
+        )
+      ]
+    )
+  end
+
+  sig do
+    params(
+      definition: ::AttrJson::AttributeDefinition,
+      custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace
+    )
+    .void
+  end
+  def add_methods_for_attributes(definition, custom_module_rbi)
+    # set methods can receive an argument of any type because attr_json will try
+    # to parse to the correct type. Example:
+    #
+    # class Post < ApplicationRecord
+    #   ...
+    #   attr_json :my_datetime, :datetime
+    # end
+    #
+    # > p = Post.new
+    # > (p.my_datetime = '2020-02-02').class
+    # => String
+    # > p.my_datetime.class
+    # => Time
+    #
+    # Also, the setter type return is the same as its argument type (before parse).
+    custom_module_rbi.create_method(
+      "#{definition.name}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T.untyped'
+        )
+      ],
+      returns: 'T.untyped'
+    )
+
+    definition_type = get_definition_type(definition)
+
+    custom_module_rbi.create_method(
+      definition.name.to_s,
+      returns: definition_type
+    )
+
+    custom_module_rbi.create_method(
+      "#{definition.name}?",
+      returns: 'T::Boolean'
+    )
+  end
+
+  sig { params(definition: ::AttrJson::AttributeDefinition).returns(String) }
+  def get_definition_type(definition)
+
+    if definition.array_type?
+      "T::Array[#{type_to_class(definition.type.base_type.type.to_s)}]"
+    else
+      "T.nilable(#{type_to_class(definition.type.type.to_s)})"
+    end
+  end
+
+  sig { params(type: String).returns(String) }
+  def type_to_class(type)
+    return 'T.untyped' unless type.present?
+
+    case type
+    when 'datetime' then 'Time'
+    when 'decimal' then 'BigDecimal'
+    when 'boolean' then 'T::Boolean'
+    else type.camelize
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+# typed: false
+class FlagShihTzuPlugin < SorbetRails::ModelPlugins::Base
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless @model_class.include?(::FlagShihTzu)
+
+    obj_custom_module_name = self.model_module_name("GeneratedFlagShihTzuMethods")
+    obj_custom_module_rbi  = root.create_module(obj_custom_module_name)
+
+    klass_custom_module_name = self.model_module_name("GeneratedFlagShihTzuClassMethods")
+    klass_custom_module_rbi  = root.create_module(klass_custom_module_name)
+
+
+    # here we re-create the model class!
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(obj_custom_module_name)
+    model_class_rbi.create_extend(klass_custom_module_name)
+
+    # then create custom methods, constants, etc. for this module.
+    add_class_methods(klass_custom_module_rbi)
+
+    if @model_class.flag_columns.present?
+      @model_class
+        .flag_columns
+        .each do |column|
+          add_methods_for_column(column, obj_custom_module_rbi)
+        end
+    end
+
+    if @model_class.flag_mapping.present?
+      @model_class
+        .flag_mapping
+        .each do |column, flags|
+          flags.keys
+            .select { |flag_key| really_has_the_flag?(flag_key) }
+            .each do |flag_key|
+              add_methods_for_flag(column, flag_key, obj_custom_module_rbi)
+            end
+        end
+    end
+  end
+
+  private
+
+  sig { params(custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_class_methods(custom_module_rbi)
+    # https://github.com/pboling/flag_shih_tzu/blob/6a3f1c5f62bd56aa932252eef935826c9674b096/lib/flag_shih_tzu.rb#L12
+    custom_module_rbi.create_method(
+      'flag_options',
+      returns: 'T::Hash[String, T::Hash[Symbol, T.untyped]]'
+    )
+
+    # https://github.com/pboling/flag_shih_tzu/blob/6a3f1c5f62bd56aa932252eef935826c9674b096/lib/flag_shih_tzu.rb#L13
+    custom_module_rbi.create_method(
+      'flag_mapping',
+      returns: 'T::Hash[String, T::Hash[Symbol, Integer]]'
+    )
+
+    # https://github.com/pboling/flag_shih_tzu/blob/6a3f1c5f62bd56aa932252eef935826c9674b096/lib/flag_shih_tzu.rb#L14
+    custom_module_rbi.create_method(
+      'flag_columns',
+      returns: 'T::Array[Symbol]'
+    )
+
+    # https://github.com/pboling/flag_shih_tzu#updating-flag-column-by-raw-sql
+    custom_module_rbi.create_method(
+      'set_flag_sql',
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'flag',
+          type: 'Symbol'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T::Boolean'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'colmn',
+          type: 'T.nilable(String)'
+        ),
+        ::Parlour::RbiGenerator::Parameter.new(
+          'custom_table_name',
+          type: 'T.any(String, Symbol)'
+        )
+      ],
+      returns: 'T::Hash[String, T::Hash[Symbol, T.untyped]]'
+    )
+
+    if @model_class.flag_mapping.present?
+      # https://github.com/pboling/flag_shih_tzu#support-for-manually-building-conditions
+      @model_class
+        .flag_mapping
+        .flat_map { |_, flags| flags.keys }
+        .each do |flag_key|
+          next unless really_has_the_flag?(flag_key)
+
+          custom_module_rbi.create_method(
+            "#{flag_key}_condition",
+            parameters: [
+              ::Parlour::RbiGenerator::Parameter.new(
+                'options',
+                type: 'T.nilable(T::Hash[Symbol, T.untyped])'
+              )
+            ],
+            returns: 'String'
+          )
+
+          custom_module_rbi.create_method(
+            "not_#{flag_key}_condition",
+            parameters: [
+              ::Parlour::RbiGenerator::Parameter.new(
+                'options',
+                type: 'T.nilable(T::Hash[Symbol, T.untyped])'
+              )
+            ],
+            returns: 'String'
+          )
+        end
+    end
+  end
+
+  # https://github.com/pboling/flag_shih_tzu#generated-boolean-patterned-instance-methods
+  sig { params(column: String, custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_methods_for_column(column, custom_module_rbi)
+    custom_module_rbi.create_method(
+      "all_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "selected_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "select_all_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "unselect_all_#{column}",
+      returns: 'T::Array[Symbol]'
+    )
+
+    custom_module_rbi.create_method(
+      "selected_#{column}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'chosen_flags',
+          type: 'T.nilable(T::Array[Symbol])'
+        )
+      ],
+      returns: 'T::Array[Symbol]'
+    )
+
+  end
+
+  # https://github.com/pboling/flag_shih_tzu#generated-boolean-patterned-instance-methods
+  sig { params(column: String, flag_key: Symbol, custom_module_rbi: Parlour::RbiGenerator::ModuleNamespace).void }
+  def add_methods_for_flag(column, flag_key, custom_module_rbi)
+    custom_module_rbi.create_method(flag_key.to_s, returns: 'T::Boolean')
+    custom_module_rbi.create_method("#{flag_key}?", returns: 'T::Boolean')
+    custom_module_rbi.create_method(
+      "#{flag_key}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T::Boolean'
+        )
+      ],
+      returns: 'T::Boolean'
+    )
+
+    custom_module_rbi.create_method("not_#{flag_key}", returns: 'T::Boolean')
+    custom_module_rbi.create_method("not_#{flag_key}?", returns: 'T::Boolean')
+    custom_module_rbi.create_method(
+      "not_#{flag_key}=",
+      parameters: [
+        ::Parlour::RbiGenerator::Parameter.new(
+          'value',
+          type: 'T::Boolean'
+        )
+      ],
+      returns: 'T::Boolean'
+    )
+
+    custom_module_rbi.create_method("#{flag_key}_changed?", returns: 'T::Boolean')
+
+    custom_module_rbi.create_method("has_#{flag_key}?", returns: 'T::Boolean')
+
+    if @model_class.flag_options[column][:bang_methods]
+      custom_module_rbi.create_method("#{flag_key}!", returns: 'T::Boolean')
+      custom_module_rbi.create_method("not_#{flag_key}!", returns: 'T::Boolean')
+    end
+  end
+
+  sig { params(flag_name: Symbol).returns(T::Boolean) }
+  def really_has_the_flag?(flag_name)
+    @model_class.respond_to?("#{flag_name}_condition")
+  end
+end

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

@@ -43,5 +43,25 @@ class KaminariPlugin < SorbetRails::ModelPlugins::Base
       return_type: "Integer",
       class_method: true,
     )
+
+    # https://github.com/kaminari/kaminari/blob/c5186f5d9b7f23299d115408e62047447fd3189d/kaminari-core/lib/kaminari/models/page_scope_methods.rb#L82
+    model_relation_rbi = root.create_class(self.model_relation_class_name)
+    model_relation_rbi.create_method(
+      'last_page?',
+      parameters: nil,
+      return_type: 'T::Boolean',
+    )
+    model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
+    model_assoc_relation_rbi.create_method(
+      'last_page?',
+      parameters: nil,
+      return_type: 'T::Boolean',
+    )
+    collection_proxy_rbi = root.create_class(self.model_assoc_proxy_class_name)
+    collection_proxy_rbi.create_method(
+      'last_page?',
+      parameters: nil,
+      return_type: 'T::Boolean',
+    )
   end
 end

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

@@ -0,0 +1,76 @@
+# typed: strict
+class MoneyRailsPlugin < SorbetRails::ModelPlugins::Base
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def allows_nil(attribute)
+    validators = model_class.validators_on(attribute)
+    return false if validators.empty?
+
+    validators.any? do |validator|
+      validator.respond_to?(:options) &&
+        validator.options[:allow_nil]
+    end
+  end
+
+  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless exists_class_method?(:monetize)
+
+    # money-rails gives us a hash mapping the monetized attribute to its subunit
+    # equivalent, eg: `{"price": "price_cents"}`
+    monetized_attributes = T.let(
+      T.unsafe(model_class).monetized_attributes,
+      T::Hash[String,String]
+    )
+
+    return if monetized_attributes.empty?
+
+    module_name = model_module_name("GeneratedMoneyRailsMethods")
+    module_rbi = root.create_module(module_name)
+
+    model_class_rbi = root.create_class(model_class_name)
+    model_class_rbi.create_include(module_name)
+
+    monetized_attributes.each do |name, subunit_name|
+      validators = model_class.validators_on(name)
+
+      money_attribute_type = allows_nil(name) ? "T.nilable(::Money)" : "::Money"
+      subunit_attribute_type = allows_nil(name) ? "T.nilable(Integer)" : "Integer"
+
+      module_rbi.create_method(
+        name,
+        return_type: money_attribute_type
+      )
+
+      module_rbi.create_method(
+        subunit_name,
+        return_type: subunit_attribute_type
+      )
+
+      module_rbi.create_method(
+        "#{name}_money_before_type_cast",
+        return_type: 'T.untyped'
+      )
+
+      module_rbi.create_method(
+        "#{name}=",
+        parameters:  [
+           Parlour::RbiGenerator::Parameter.new("value", type: money_attribute_type)
+        ],
+        return_type: nil
+      )
+
+      module_rbi.create_method(
+        "#{subunit_name}=",
+        parameters:  [
+           Parlour::RbiGenerator::Parameter.new("value", type: subunit_attribute_type)
+        ],
+        return_type: nil
+      )
+
+      module_rbi.create_method(
+        "currency_for_#{name}",
+        return_type: "T.nilable(::Money::Currency)"
+      )
+    end
+  end
+end

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

@@ -45,7 +45,7 @@ class ShrinePlugin < SorbetRails::ModelPlugins::Base
             parameters: [
               ::Parlour::RbiGenerator::Parameter.new(
                 "url",
-                type: T.untyped # TODO likely T.nilable(String)
+                type: "T.untyped" # TODO likely T.nilable(String)
               ),
             ],
           )

data/lib/sorbet-rails/job_rbi_formatter.rb

@@ -80,7 +80,7 @@ module SorbetRails
 
     sig { returns(String) }
     def generate_rbi
-      puts "-- Generate sigs for mailer #{@job_class.name} --"
+      puts "-- Generate sigs for ActiveJob #{@job_class.name} --"
       populate_rbi
       @rbi_generator.rbi
     end

data/lib/sorbet-rails/model_column_utils.rb

@@ -17,7 +17,7 @@ module SorbetRails::ModelColumnUtils
       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 = "T.nilable(#{type})" if nilable && type != "T.untyped"
       type
     end
   end

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

@@ -34,7 +34,7 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
   def populate_single_assoc_getter_setter(assoc_module_rbi, assoc_name, reflection)
     # TODO allow people to specify the possible values of polymorphic associations
     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})"
+    assoc_type = (belongs_to_and_required?(reflection) || has_one_and_required?(reflection) || assoc_class == "T.untyped") ? assoc_class : "T.nilable(#{assoc_class})"
 
     params = [
       Parameter.new("*args", type: "T.untyped"),

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

@@ -25,7 +25,8 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
     # <Model>::Relation class.
     # rails/activerecord/lib/active_record/querying.rb
     model_query_relation_methods = [
-      :select, :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
+      # :select,
+      :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
       :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :or,
       :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
     ]
@@ -39,6 +40,42 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
         builtin_query_method: true,
       ) if exists_class_method?(method_name)
     end
+    if exists_class_method?("select")
+      # `select` can be used with a block to return an array, or with a list of column name
+      # to return a relation object that can be chained.
+      # I've seen usage of `select` with a block more often than with a list of column name.
+      # here we define select as taking a block, and add a `select_column` method for the other usage
+      add_relation_query_method(
+        root,
+        "select",
+        parameters: [
+          Parameter.new("&block", type: "T.proc.params(e: #{self.model_class_name}).returns(T::Boolean)"),
+        ],
+        builtin_query_method: true,
+        custom_return_value: "T::Array[#{self.model_class_name}]",
+      )
+      add_relation_query_method(
+        root,
+        "select_columns", # select_column is injected by sorbet-rails
+        parameters: [
+          Parameter.new("*args", type: "T.any(String, Symbol, T::Array[T.any(String, Symbol)])"),
+        ],
+        builtin_query_method: true,
+      )
+    end
+
+    # https://api.rubyonrails.org/v6.1.4/classes/ActiveRecord/QueryMethods/WhereChain.html#method-i-missing
+    # where.missing is only available in Rails 6.1 and above
+    if Rails.version >= "6.1"
+      add_relation_query_method(
+        root,
+        "where_missing", # where_missing is injected by sorbet-rails
+        parameters: [
+          Parameter.new("*args", type: "Symbol"),
+        ],
+        builtin_query_method: true,
+      )
+    end
 
     add_relation_query_method(
       root,

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

@@ -60,9 +60,10 @@ class SorbetRails::ModelPlugins::ActiveRecordSerializedAttribute < SorbetRails::
       # 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
+    when 'Object', ''
       'T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)'
+    else
+      serialization_coder.to_s
     end
   end
 end

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

@@ -35,7 +35,14 @@ module SorbetRails::ModelPlugins
       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
+      object_class = column_type.coder.try(:object_class)
+      if object_class
+        object_class
+      elsif column_type.coder.is_a? Class
+        column_type.coder
+      else
+        Object
+      end
     end
   end
 end

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

@@ -39,7 +39,7 @@ class SorbetRails::ModelPlugins::CustomFinderMethods < SorbetRails::ModelPlugins
     # allow common cases find_by_id
     custom_module_rbi.create_method(
       "find_by_id",
-      parameters: [ Parameter.new("id", type: "Integer") ],
+      parameters: [ Parameter.new("id", type: "T.nilable(Integer)") ],
       return_type: "T.nilable(#{self.model_class_name})",
     )
     custom_module_rbi.create_method(

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

@@ -81,6 +81,18 @@ 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
+    when :aasm
+      require('sorbet-rails/gem_plugins/aasm_plugin')
+      AasmPlugin
+    when :money_rails
+      require('sorbet-rails/gem_plugins/money_rails_plugin')
+      MoneyRailsPlugin
     else
       raise UnrecognizedPluginName.new(
         "Unrecognized plugin with name: #{plugin_name}. Please check available plugins in the

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -28,7 +28,10 @@ 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
+      puts "Note: Unable to create new instance of #{model_class_name}"
+      puts "Got a #{err.class}, with this message: #{err.message}"
+      puts
     end
   end
 
@@ -77,7 +80,7 @@ class SorbetRails::ModelRbiFormatter
     model_relation_rbi.create_include(self.model_query_methods_returning_relation_module_name)
     model_relation_rbi.create_constant(
       "Elem",
-      value: "type_member(fixed: #{model_class_name})",
+      value: "type_member {{fixed: #{model_class_name}}}",
     )
 
     model_assoc_relation_rbi = root.create_class(
@@ -87,7 +90,7 @@ class SorbetRails::ModelRbiFormatter
     model_assoc_relation_rbi.create_include(self.model_query_methods_returning_assoc_relation_module_name)
     model_assoc_relation_rbi.create_constant(
       "Elem",
-      value: "type_member(fixed: #{model_class_name})",
+      value: "type_member {{fixed: #{model_class_name}}}",
     )
 
     collection_proxy_rbi = root.create_class(
@@ -97,7 +100,7 @@ class SorbetRails::ModelRbiFormatter
     collection_proxy_rbi.create_include(self.model_query_methods_returning_assoc_relation_module_name)
     collection_proxy_rbi.create_constant(
       "Elem",
-      value: "type_member(fixed: #{self.model_class_name})",
+      value: "type_member {{fixed: #{self.model_class_name}}}",
     )
 
     model_rbi = root.create_class(