sorbet-rails 0.4.0 → 0.5.0

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

@@ -0,0 +1,43 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveRecordEnum < SorbetRails::ModelPlugins::Base
+
+  sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    return unless model_class.defined_enums.size > 0
+
+    enum_module_name = model_module_name("EnumInstanceMethods")
+    enum_module_rbi = root.create_module(enum_module_name)
+    enum_module_rbi.create_extend("T::Sig")
+
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_class_rbi.create_include(enum_module_name)
+
+    model_relation_shared_rbi = root.create_module(self.model_relation_shared_module_name)
+
+    # TODO: add any method for signature verification?
+    model_class.defined_enums.sort.each do |enum_name, enum_hash|
+      model_class_rbi.create_method(
+        enum_name.pluralize,
+        return_type: "T::Hash[T.any(String, Symbol), Integer]",
+        class_method: true,
+      )
+      enum_hash.keys.each do |enum_val|
+        enum_module_rbi.create_method(
+          "#{enum_val}?",
+          return_type: "T::Boolean",
+        )
+        enum_module_rbi.create_method(
+          "#{enum_val}!",
+          return_type: nil, # void
+        )
+        # force generating these methods because sorbet's hidden-definitions generate & override them
+        model_class_rbi.create_method(
+          "#{enum_val}",
+          return_type: self.model_relation_class_name,
+          class_method: true,
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveRecordFinderMethods < SorbetRails::ModelPlugins::Base
+
+  sig { implementation.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)
+
+    model_relation_class_rbi = root.create_class(self.model_relation_class_name)
+    create_finder_methods_for(model_relation_class_rbi, class_method: false)
+
+    model_assoc_proxy_class_rbi = root.create_class(self.model_assoc_proxy_class_name)
+    create_finder_methods_for(model_assoc_proxy_class_rbi, class_method: false)
+  end
+
+  sig { params(class_rbi: Parlour::RbiGenerator::ClassNamespace, class_method: T::Boolean).void }
+  def create_finder_methods_for(class_rbi, class_method:)
+    class_rbi.create_method(
+      "find",
+      parameters: [ Parameter.new("*args", type: "T.untyped") ],
+      return_type: self.model_class_name,
+      class_method: class_method,
+    )
+    class_rbi.create_method(
+      "find_by",
+      parameters: [ Parameter.new("*args", type: "T.untyped") ],
+      return_type: "T.nilable(#{self.model_class_name})",
+      class_method: class_method,
+    )
+    class_rbi.create_method(
+      "find_by!",
+      parameters: [ Parameter.new("*args", type: "T.untyped") ],
+      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
+
+    # 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(
+        method_name,
+        parameters: [ Parameter.new("*args", type: "T.untyped") ],
+        return_type: "T::Boolean",
+        class_method: class_method,
+      )
+    end
+  end
+
+  sig {
+    params(
+      class_rbi: Parlour::RbiGenerator::ClassNamespace,
+      method_name: String,
+      class_method: T::Boolean,
+    ).
+    void
+  }
+  def create_finder_method_pair(class_rbi, method_name, class_method)
+    class_rbi.create_method(
+      method_name,
+      return_type: "T.nilable(#{self.model_class_name})",
+      class_method: class_method,
+    )
+    class_rbi.create_method(
+      "#{method_name}!",
+      return_type: self.model_class_name,
+      class_method: class_method,
+    )
+  end
+end

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

@@ -0,0 +1,28 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveRecordNamedScope < SorbetRails::ModelPlugins::Base
+
+  sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    ar_named_scope_rbi = root.create_module(self.model_relation_shared_module_name)
+    @model_class.methods.sort.each do |method_name|
+      method_obj = @model_class.method(method_name)
+      next unless method_obj.present? && method_obj.source_location.present?
+      # we detect sscopes defined in a model by 2 criteria:
+      # - they don't have an owner name
+      # - they are defined in 'activerecord/lib/active_record/scoping/named.rb'
+      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/scoping/named.rb
+      next unless method_obj.owner.name == nil
+      source_file = method_obj.source_location[0]
+      next unless source_file.include?("lib/active_record/scoping/named.rb")
+
+      ar_named_scope_rbi.create_method(
+        method_name.to_s,
+        parameters: [
+          Parameter.new("*args", type: "T.untyped"),
+        ],
+        return_type: self.model_relation_class_name,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugins::Base
+
+  sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    # All is a named scope that most method from ActiveRecord::Querying delegate to
+    # rails/activerecord/lib/active_record/querying.rb:21
+    ar_querying_rbi = root.create_module(self.model_relation_shared_module_name)
+    ar_querying_rbi.create_method(
+      "all",
+      return_type: self.model_relation_class_name,
+    )
+    ar_querying_rbi.create_method(
+      "unscoped",
+      parameters: [
+        Parameter.new("&block", type: "T.nilable(T.proc.void)"),
+      ],
+      return_type: self.model_relation_class_name,
+    )
+
+    # It's not possible to typedef all methods in ActiveRecord::Querying module to have the
+    # matching type. By generating model-specific sig, we can typedef these methods to return
+    # <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,
+      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :extending, :or,
+      :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
+    ]
+    model_query_relation_methods.each do |method_name|
+      ar_querying_rbi.create_method(
+        method_name.to_s,
+        parameters: [
+          Parameter.new("*args", type: "T.untyped"),
+          Parameter.new("&block", type: "T.nilable(T.proc.void)"),
+        ],
+        return_type: self.model_relation_class_name,
+      ) if exists_class_method?(method_name)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::ActiveRelationWhereNot < SorbetRails::ModelPlugins::Base
+
+  sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    where_not_module_name = self.model_module_name("ActiveRelation_WhereNot")
+    where_not_module_rbi = root.create_module(where_not_module_name)
+
+    model_relation_class_rbi = root.create_class(self.model_relation_class_name)
+    model_relation_class_rbi.create_include(where_not_module_name)
+
+    model_assoc_proxy_class_rbi = root.create_class(self.model_assoc_proxy_class_name)
+    model_assoc_proxy_class_rbi.create_include(where_not_module_name)
+
+    # TODO: where.not is a special case that we replace it with a `where_not` method
+    # `where` when not given parameters will return a `ActiveRecord::QueryMethods::WhereChain`
+    # instance that has a method `not` on it
+    where_not_module_rbi.create_method(
+      "not",
+      parameters: [
+        Parameter.new("opts", type: "T.untyped", default: nil),
+        Parameter.new("*rest", type: "T.untyped", default: nil),
+      ],
+      return_type: "T.self_type",
+    )
+  end
+end

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

@@ -0,0 +1,33 @@
+# typed: strict
+require('parlour')
+require('sorbet-rails/model_utils')
+module SorbetRails::ModelPlugins
+  class Base < ::Parlour::Plugin
+    extend T::Sig
+    extend T::Helpers
+    include SorbetRails::ModelUtils
+
+    abstract!
+
+    # convenient rename
+    Parameter = ::Parlour::RbiGenerator::Parameter
+
+    sig { implementation.returns(T.class_of(ActiveRecord::Base)) }
+    attr_reader :model_class
+
+    sig { returns(T::Set[String]) }
+    attr_reader :available_classes
+
+    sig {
+      params(
+        model_class: T.class_of(ActiveRecord::Base),
+        available_classes: T::Set[String],
+      ).
+      void
+    }
+    def initialize(model_class, available_classes)
+      @model_class = T.let(model_class, T.class_of(ActiveRecord::Base))
+      @available_classes = T.let(available_classes, T::Set[String])
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::CustomFinderMethods < SorbetRails::ModelPlugins::Base
+
+  sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    model_class_rbi = root.create_class(self.model_class_name)
+    model_relation_class_rbi = root.create_class(self.model_relation_class_name)
+    model_assoc_proxy_class_rbi = root.create_class(self.model_assoc_proxy_class_name)
+
+    # include the actual module
+    model_class_rbi.create_extend("SorbetRails::CustomFinderMethods")
+    model_relation_class_rbi.create_include("SorbetRails::CustomFinderMethods")
+    model_assoc_proxy_class_rbi.create_include("SorbetRails::CustomFinderMethods")
+
+    custom_module_name = self.model_module_name("CustomFinderMethods")
+    custom_module_rbi = root.create_module(custom_module_name)
+
+    # and include the rbi module
+    model_class_rbi.create_extend(custom_module_name)
+    model_relation_class_rbi.create_include(custom_module_name)
+    model_assoc_proxy_class_rbi.create_include(custom_module_name)
+
+    custom_module_rbi.create_method(
+      "first_n",
+      parameters: [ Parameter.new("limit", type: "Integer") ],
+      return_type: "T::Array[#{self.model_class_name}]",
+    )
+
+    custom_module_rbi.create_method(
+      "last_n",
+      parameters: [ Parameter.new("limit", type: "Integer") ],
+      return_type: "T::Array[#{self.model_class_name}]",
+    )
+
+    custom_module_rbi.create_method(
+      "find_n",
+      parameters: [ Parameter.new("*args", type: "T::Array[T.any(Integer, String)]") ],
+      return_type: "T::Array[#{self.model_class_name}]",
+    )
+
+    # allow common cases find_by_id
+    custom_module_rbi.create_method(
+      "find_by_id",
+      parameters: [ Parameter.new("id", type: "Integer") ],
+      return_type: "T.nilable(#{self.model_class_name})",
+    )
+    custom_module_rbi.create_method(
+      "find_by_id!",
+      parameters: [ Parameter.new("id", type: "Integer") ],
+      return_type: self.model_class_name,
+    )
+  end
+end

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

@@ -0,0 +1,49 @@
+# typed: strict
+require ('sorbet-rails/model_plugins/base')
+class SorbetRails::ModelPlugins::EnumerableCollections < SorbetRails::ModelPlugins::Base
+
+  sig { implementation.params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate(root)
+    # model 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)
+
+    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|
+      elem = self.model_class_name
+      model_assoc_proxy_class_rbi.create_method(
+        method_name,
+        parameters: [
+          Parameter.new("*records", type: "T.any(#{elem}, T::Array[#{elem}])"),
+        ],
+        return_type: "T.self_type",
+      )
+    end
+  end
+
+  sig { params(class_rbi: Parlour::RbiGenerator::ClassNamespace).void }
+  def create_enumerable_methods_for(class_rbi)
+    class_rbi.create_include("Enumerable")
+    class_rbi.create_method(
+      "each",
+      parameters: [
+        Parameter.new("&block", type: "T.proc.params(e: #{self.model_class_name}).void")
+      ],
+      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}]",
+    )
+  end
+end

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

@@ -0,0 +1,45 @@
+# typed: true
+require('sorbet-rails/model_plugins/base')
+require('sorbet-rails/model_plugins/active_record_enum')
+require('sorbet-rails/model_plugins/active_record_querying')
+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')
+
+module SorbetRails::ModelPlugins
+  extend T::Sig
+
+  @@plugins = T.let(
+    [
+      ActiveRecordEnum,
+      ActiveRecordNamedScope,
+      ActiveRecordQuerying,
+      ActiveRelationWhereNot,
+      ActiveRecordAttribute,
+      ActiveRecordAssoc,
+      ActiveRecordFinderMethods,
+      CustomFinderMethods,
+      EnumerableCollections,
+    ],
+    T::Array[T.class_of(Base)]
+  )
+
+  sig { params(plugin: T.class_of(Base)).void }
+  def register_plugin(plugin)
+    @@plugins.push(plugin) unless @@plugins.include?(plugin)
+  end
+
+  sig { params(plugins: T::Array[T.class_of(Base)]).void }
+  def set_plugins(plugins)
+    @@plugins = plugins
+  end
+
+  sig { returns(T::Array[T.class_of(Base)]) }
+  def get_plugins
+    @@plugins
+  end
+end

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -1,387 +1,133 @@
-# typed: true
-class ModelRbiFormatter
-  MODEL_RELATION_SHARED_MODULE_SUFFIX = "ModelRelationShared"
-  MODEL_CLASS_MODULE_SUFFIX = "ClassMethods"
-  MODEL_INSTANCE_MODULE_SUFFIX = "InstanceMethods"
-
+# typed: strict
+require('parlour')
+require('sorbet-rails/model_utils')
+require('sorbet-rails/model_plugins/plugins')
+
+class SorbetRails::ModelRbiFormatter
+  extend T::Sig
+  extend SorbetRails::ModelPlugins
+  include SorbetRails::ModelUtils
+
+  sig { implementation.returns(T.class_of(ActiveRecord::Base)) }
+  attr_reader :model_class
+
+  sig { returns(T::Set[String]) }
+  attr_reader :available_classes
+
+  sig {
+    params(
+      model_class: T.class_of(ActiveRecord::Base),
+      available_classes: T::Set[String],
+    ).
+    void
+  }
   def initialize(model_class, available_classes)
-    @model_class = model_class
-    @available_classes = available_classes
-    @columns_hash = model_class.table_exists? ? model_class.columns_hash : {}
-    @generated_instance_module_sigs = ActiveSupport::HashWithIndifferentAccess.new
-    @generated_instance_sigs = ActiveSupport::HashWithIndifferentAccess.new
-    @generated_class_sigs = ActiveSupport::HashWithIndifferentAccess.new
-    @generated_scope_sigs = ActiveSupport::HashWithIndifferentAccess.new
-    @generated_querying_sigs = ActiveSupport::HashWithIndifferentAccess.new
-    @model_relation_class_name = "#{@model_class.name}::ActiveRecord_Relation"
+    @model_class = T.let(model_class, T.class_of(ActiveRecord::Base))
+    @available_classes = T.let(available_classes, T::Set[String])
     begin
       # Load all dynamic instance methods of this model by instantiating a fake model
       @model_class.new unless @model_class.abstract_class?
-    rescue StandardError
-      puts "Note: Unable to create new instance of #{model_class.name}"
+    rescue StandardError => err
+      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} --"
-    populate_activerecord_querying_methods
-    populate_named_scope_methods
-    populate_generated_column_methods
-    populate_generated_association_methods
-    populate_generated_enum_methods
-
-    @buffer = []
-    @buffer << draw_file_header_and_base_classes
-
-    @buffer << draw_module_header("#{@model_class.name}::#{MODEL_INSTANCE_MODULE_SUFFIX}")
-    @model_class.instance_methods.sort.each do |method_name|
-      expected_sig = @generated_instance_module_sigs[method_name]
-      next unless expected_sig.present?
-      method_obj = @model_class.instance_method(method_name)
-      draw_method(method_name, method_obj, expected_sig)
-    end
-    @buffer << draw_module_or_class_footer
-
-    # TODO Enum methods need to be defined under the class definition because sorbet generates them
-    # in the hidden-definition.rbi
-    # When this issue is resolved, they might go away by running `srb rbi hidden-definitions`
-    # This is a sure way to make it work though.
-    # https://github.com/sorbet/sorbet/issues/1161
-    @buffer << draw_class_header("#{@model_class.name}") # ::#{MODEL_CLASS_MODULE_SUFFIX}")
-    @model_class.instance_methods.sort.each do |method_name|
-      expected_sig = @generated_instance_sigs[method_name]
-      next unless expected_sig.present?
-      method_obj = @model_class.instance_method(method_name)
-      draw_method(method_name, method_obj, expected_sig)
-    end
-    @model_class.methods.sort.each do |method_name|
-      expected_sig = @generated_class_sigs[method_name]
-      next unless expected_sig.present?
-      method_obj = @model_class.method(method_name)
-      draw_method(method_name, method_obj, expected_sig, is_class_method: true)
-    end
-    @buffer << draw_module_or_class_footer
-
-    # <Model>::MODEL_RELATION_SHARED_MODULE_SUFFIX is a fake module added so that
-    # when a method is defined in this module, it'll be added to both the Model class
-    # as a class method and to its relation as an instance method.
-    #
-    # We need to define the module after the other classes
-    # to work around Sorbet loading order bug
-    # https://sorbet-ruby.slack.com/archives/CHN2L03NH/p1556065791047300
-    @buffer << draw_module_header("#{@model_class.name}::#{MODEL_RELATION_SHARED_MODULE_SUFFIX}")
-    # For simplicity, generate both in the same module for now.
-    # We don't need to define two fake modules to share methods between <Model> and <Relation>
-    ({}.
-      merge(@generated_scope_sigs).
-      merge(@generated_querying_sigs)
-    ).each do |method_name, expected_sig|
-      method_obj = @model_class.method(method_name) if @model_class.methods.include?(method_name.to_sym)
-      # this is not a class method because it is added to a module
-      draw_method(method_name, method_obj, expected_sig)
-    end
-    @buffer << draw_module_or_class_footer
-    @buffer.join("\n")
-  end
-
-  def draw_method(method_name, method_obj, expected_sig, is_class_method: false)
-    if !method_obj.present?
-      # not very actionable because this could be a method in a newer version of Rails
-      # puts "Skip method '#{method_name}' because there is no matching method object."
-      return
-    end
-    @buffer << generate_method_sig(method_name, expected_sig, is_class_method).indent(2)
-  end
-
-  def populate_activerecord_querying_methods
-    # All is a named scope that most method from ActiveRecord::Querying delegate to
-    # rails/activerecord/lib/active_record/querying.rb:21
-    @generated_scope_sigs["all"] = { ret: @model_relation_class_name }
-    @generated_scope_sigs["unscoped"] = {
-      ret: @model_relation_class_name,
-      args: [
-        { name: :block, arg_type: :block, value_type: 'T.nilable(T.proc.void)' },
-      ]
-    }
-    # It's not possible to typedef all methods in ActiveRecord::Querying module to have the
-    # matching type. By generating model-specific sig, we can typedef these methods to return
-    # <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,
-      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :extending, :or,
-      :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
-    ]
-    model_query_relation_methods.each do |method_name|
-      @generated_querying_sigs[method_name.to_s] = {
-        args: [
-          {name: :args, arg_type: :rest, value_type: 'T.untyped'},
-          {name: :block, arg_type: :block, value_type: 'T.nilable(T.proc.void)'},
-        ],
-        ret: @model_relation_class_name,
-      }
-    end
-  end
-
-  def populate_named_scope_methods
-    @model_class.methods.sort.each do |method_name|
-      method_obj = @model_class.method(method_name)
-      next unless method_obj.present? && method_obj.source_location.present?
-      # we detect sscopes defined in a model by 2 criteria:
-      # - they don't have an owner name
-      # - they are defined in 'activerecord/lib/active_record/scoping/named.rb'
-      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/scoping/named.rb
-      next unless method_obj.owner.name == nil
-      source_file = method_obj.source_location[0]
-      next unless source_file.include?('lib/active_record/scoping/named.rb')
-      @generated_scope_sigs[method_name] = {
-        args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
-        ret: @model_relation_class_name,
-      }
-    end
-  end
-
-  def populate_generated_column_methods
-    @columns_hash.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
-        @generated_instance_module_sigs.merge!({
-          "#{column_name}" => { ret: "String" },
-          "#{column_name}=" => {
-            args: [ name: :value, arg_type: :req, value_type: assignable_type],
-          },
-        })
-      else
-        column_type = type_for_column_def(column_def)
-        @generated_instance_module_sigs.merge!({
-          "#{column_name}" => { ret: column_type },
-          "#{column_name}=" => {
-            args: [ name: :value, arg_type: :req, value_type: column_type ],
-          },
-        })
-      end
-
-      @generated_instance_module_sigs["#{column_name}?"] = {
-        ret: "T::Boolean",
-        args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
-      }
-    end
-  end
-
-  def populate_generated_association_methods
-    @model_class.reflections.each do |assoc_name, reflection|
-      reflection.collection? ?
-        populate_collection_assoc_getter_setter(assoc_name, reflection) :
-        populate_single_assoc_getter_setter(assoc_name, reflection)
-    end
-  end
 
-  def populate_single_assoc_getter_setter(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 = "T.nilable(#{assoc_class})"
-    if reflection.belongs_to?
-      # if this is a belongs_to connection, we may be able to detect whether
-      # this field is required & use a stronger type
-      column_def = @columns_hash[reflection.foreign_key.to_s]
-      if column_def
-        assoc_type = assoc_class if !column_def.null
-      end
+    # Collect the instances of each plugin into an array
+    plugin_instances = self.class.get_plugins.map do |plugin_klass|
+      plugin_klass.new(model_class, available_classes)
     end
 
-    @generated_instance_sigs.merge!({
-      "#{assoc_name}" => { ret: assoc_type },
-      "#{assoc_name}=" => {
-        args: [ name: :value, arg_type: :req, value_type: assoc_type ],
-      },
-    })
-  end
-
-  def populate_collection_assoc_getter_setter(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}"
-    relation_class = relation_should_be_untyped?(reflection) ?
-      "ActiveRecord::Associations::CollectionProxy" :
-      "#{assoc_class}::ActiveRecord_Associations_CollectionProxy"
-    @generated_instance_sigs.merge!({
-      "#{assoc_name}" => { ret: relation_class },
-      "#{assoc_name}=" => {
-        args: [ name: :value, arg_type: :req, value_type: "T.any(T::Array[#{assoc_class}], #{relation_class})" ],
-      },
-    })
-  end
-
-  def populate_generated_enum_methods
-    @model_class.defined_enums.each do |enum_name, enum_hash|
-      @generated_class_sigs["#{enum_name.pluralize}"] = { ret: "T::Hash[T.any(String, Symbol), Integer]"}
-      enum_hash.keys.each do |enum_val|
-        @generated_instance_module_sigs["#{enum_val}?"] = { ret: "T::Boolean" }
-        @generated_instance_module_sigs["#{enum_val}!"] = { ret: nil }
-        @generated_scope_sigs["#{enum_val}"] = {
-          args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
-          ret: @model_relation_class_name,
-        }
-        # force generating these methods because sorbet's hidden-definitions generate & override them
-        @generated_class_sigs["#{enum_val}"] = {
-          args: [ name: :args, arg_type: :rest, value_type: 'T.untyped' ],
-          ret: @model_relation_class_name,
-        }
+    generator = Parlour::RbiGenerator.new(break_params: 3)
+    run_plugins(plugin_instances, generator, allow_failure: true)
+    # Generate the base after the plugins because when ConflictResolver merge the modules,
+    # it'll put the modules at the last position merged. Putting the base stuff
+    # last will keep the order consistent and minimize changes when new plugins are added.
+    generate_base_rbi(generator.root)
+
+    Parlour::ConflictResolver.new.resolve_conflicts(generator.root) do |msg, candidates|
+      puts "Conflict: #{msg}. Skip following methods"
+      candidates.each do |c|
+        puts "- Method `#{c.name}` generated by #{c.generated_by.class.name}"
       end
+      nil
     end
-  end
-
-  def assoc_should_be_untyped?(reflection)
-    polymorphic_assoc?(reflection) || !@available_classes.include?(reflection.klass.name)
-  end
-
-  def relation_should_be_untyped?(reflection)
-    # only type the relation we'll generate
-    assoc_should_be_untyped?(reflection) || !@available_classes.include?(reflection.klass.name)
-  end
 
-  def polymorphic_assoc?(reflection)
-    reflection.through_reflection ?
-      polymorphic_assoc?(reflection.source_reflection) :
-      reflection.polymorphic?
-  end
-
-  def draw_file_header_and_base_classes
-    # We define a custom <ModelName>::Relation class so that it can be extended
-    # to contain custom scopes for each models
-    <<~MESSAGE
-      # This is an autogenerated file for dynamic methods in #{@model_class.name}
-      # Please rerun rake rails_rbi:models to regenerate.
-      # typed: strong
-
-      class #{@model_relation_class_name} < ActiveRecord::Relation
-        include #{@model_class.name}::#{MODEL_RELATION_SHARED_MODULE_SUFFIX}
-        extend T::Generic
-        Elem = type_member(fixed: #{@model_class.name})
-      end
-
-      class #{@model_class.name}::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
-        include #{@model_class.name}::#{MODEL_RELATION_SHARED_MODULE_SUFFIX}
-        extend T::Generic
-        Elem = type_member(fixed: #{@model_class.name})
-      end
-
-      class #{@model_class.name} < #{@model_class.superclass}
-        extend T::Sig
-        extend T::Generic
-        extend #{@model_class.name}::#{MODEL_RELATION_SHARED_MODULE_SUFFIX}
-        include #{@model_class.name}::#{MODEL_INSTANCE_MODULE_SUFFIX}
-        Elem = type_template(fixed: #{@model_class.name})
-      end
-    MESSAGE
-  end
-
-  def draw_module_or_class_footer
     <<~MESSAGE
-      end
-    MESSAGE
-  end
+      # This is an autogenerated file for dynamic methods in #{self.model_class_name}
+      # Please rerun rake rails_rbi:models[#{self.model_class_name}] to regenerate.
 
-  def draw_module_header(name)
-    <<~MESSAGE
-      module #{name}
-        extend T::Sig
+      #{generator.rbi}
     MESSAGE
   end
 
-  def draw_class_header(name)
-    <<~MESSAGE
-      class #{name}
-        extend T::Sig
-    MESSAGE
-  end
-
-  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
-
-    strict_type = active_record_type_to_sorbet_type(cast_type)
-
-    if column_def.respond_to?(:array?) && column_def.array?
-      strict_type = "T::Array[#{strict_type}]"
-    end
-    column_def.null ? "T.nilable(#{strict_type})" : strict_type
-  end
-
-  def active_record_type_to_sorbet_type(klass)
-    case klass
-    when ActiveRecord::Type::Boolean
-     "T::Boolean"
-    when ActiveRecord::Type::DateTime
-      DateTime
-    when ActiveRecord::Type::Date
-      Date
-    when ActiveRecord::Type::Decimal
-      BigDecimal
-    when ActiveRecord::Type::Float
-      Float
-    when ActiveRecord::Type::Time
-      Time
-    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(Array, T::Boolean, Float, Hash, Integer, String)"
-      when Object.const_defined?('ActiveRecord::Enum::EnumType') && klass.is_a?(ActiveRecord::Enum::EnumType)
-        String
-      else
-        "T.untyped"
-      end
-    end
-  end
+  sig { params(root: Parlour::RbiGenerator::Namespace).void }
+  def generate_base_rbi(root)
+    # This is the backbone of the model_rbi_formatter.
+    # It could live in a base plugin but I consider it not replacable and better to leave here
+    model_relation_rbi = root.create_class(
+      self.model_relation_class_name,
+      superclass: "ActiveRecord::Relation",
+    )
+    model_relation_rbi.create_include(self.model_relation_shared_module_name)
+    model_relation_rbi.create_extend("T::Sig")
+    model_relation_rbi.create_extend("T::Generic")
+    model_relation_rbi.create_constant(
+      "Elem",
+      value: "type_member(fixed: #{model_class_name})",
+    )
+
+    collection_proxy_rbi = root.create_class(
+      self.model_assoc_proxy_class_name,
+      superclass: "ActiveRecord::Associations::CollectionProxy",
+    )
+    collection_proxy_rbi.create_include(self.model_relation_shared_module_name)
+    collection_proxy_rbi.create_extend("T::Sig")
+    collection_proxy_rbi.create_extend("T::Generic")
+    collection_proxy_rbi.create_constant(
+      "Elem",
+      value: "type_member(fixed: #{self.model_class_name})",
+    )
+
+    model_rbi = root.create_class(
+      self.model_class_name,
+      superclass: T.must(@model_class.superclass).name,
+    )
+    model_rbi.create_extend("T::Sig")
+    model_rbi.create_extend("T::Generic")
+    model_rbi.create_extend(self.model_relation_shared_module_name)
 
-  def generate_method_sig(method_name, generated_method_def, is_class_method)
-    # generated_method_def:
-    # {
-    # .  ret: <return_type>
-    #    args: [ name: :value, arg_type: :req, value_type: "T.any(T::Array[#{assoc_class}], ActiveRecord::Relation" ]
-    #  }
-    #
-    # Generate something like this
+    # <Model>::MODEL_RELATION_SHARED_MODULE_SUFFIX is a fake module added so that
+    # when a method is defined in this module, it'll be added to both the Model class
+    # as a class method and to its relation as an instance method.
     #
-    #  sig {returns(T.nilable(String))}
-    # .def email; end
-    #  sig {params(record: T.nilable(String)).void}
-    #  def email=(record); end
-
-    param_sig = ""
-    param_def = ""
-    if generated_method_def[:args]
-      sig_args_string = generated_method_def[:args].map { |arg_def|
-        "#{arg_def[:name]}: #{arg_def[:value_type]}"
-      }.join(", ")
-      param_sig = "params(#{sig_args_string})."
-
-      param_def = generated_method_def[:args].map { |arg_def|
-        prefix = ""
-        prefix = "*" if arg_def[:arg_type] == :rest
-        prefix = "**" if arg_def[:arg_type] == :keyrest
-        prefix = "&" if arg_def[:arg_type] == :block
-
-        "#{prefix}#{arg_def[:name]}"
-      }.join(", ")
+    # We need to define the module after the other classes
+    # to work around Sorbet loading order bug
+    # https://sorbet-ruby.slack.com/archives/CHN2L03NH/p1556065791047300
+    model_relation_shared_rbi = root.create_module(self.model_relation_shared_module_name)
+    model_relation_shared_rbi.create_extend("T::Sig")
+  end
+
+  sig {
+    params(
+      plugins: T::Array[Parlour::Plugin],
+      generator: Parlour::RbiGenerator,
+      allow_failure: T::Boolean,
+    ).
+    void
+  }
+  def run_plugins(plugins, generator, allow_failure: true)
+    plugins.each do |plugin|
+      begin
+        generator.current_plugin = plugin
+        plugin.generate(generator.root)
+      rescue Exception => e
+        raise e unless allow_failure
+        puts "!!! Plugin #{plugin.class.name} threw an exception: #{e}"
+      end
     end
-
-    method_prefix = is_class_method ? 'self.' : ''
-
-    return_type = generated_method_def[:ret] ?
-      "returns(#{generated_method_def[:ret]})" :
-      "void"
-
-    <<~MESSAGE
-      sig { #{param_sig}#{return_type} }
-      def #{method_prefix}#{method_name}(#{param_def}); end
-    MESSAGE
   end
 end