sorbet-rails 0.6.5.1 → 0.7.4

data/lib/sorbet-rails/deprecation.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'active_support/deprecation'
 
 module SorbetRails

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

@@ -35,5 +35,33 @@ class KaminariPlugin < SorbetRails::ModelPlugins::Base
         Parameter.new('num', type: 'Integer')
       ],
     )
+
+    # https://github.com/kaminari/kaminari/blob/c5186f5d9b7f23299d115408e62047447fd3189d/kaminari-core/lib/kaminari/models/configuration_methods.rb#L19
+    model_class_rbi = root.create_class(model_class_name)
+    model_class_rbi.create_method(
+      "default_per_page",
+      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/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/helper_rbi_formatter.rb

@@ -16,7 +16,7 @@ class SorbetRails::HelperRbiFormatter
   def generate_rbi
     puts "-- Generate sigs for helpers --"
 
-    @parlour.root.add_comments([
+    @parlour.root.add_comment([
       'This is an autogenerated file for Rails helpers.',
       'Please rerun bundle exec rake rails_rbi:helpers to regenerate.'
     ])

data/lib/sorbet-rails/job_rbi_formatter.rb

@@ -2,74 +2,87 @@
 require('parlour')
 require('sorbet-rails/sorbet_utils.rb')
 
-class SorbetRails::JobRbiFormatter
-  extend T::Sig
+module SorbetRails
+  class JobRbiFormatter
+    extend T::Sig
 
-  Parameter = ::Parlour::RbiGenerator::Parameter
+    Parameter = ::Parlour::RbiGenerator::Parameter
 
-  sig { params(job_class: T.class_of(ActiveJob::Base)).void }
-  def initialize(job_class)
-    @job_class = T.let(job_class, T.class_of(ActiveJob::Base))
-    @parlour = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
-  end
+    sig { returns(Parlour::RbiGenerator) }
+    attr_reader :rbi_generator
+
+    sig { returns(T.class_of(ActiveJob::Base)) }
+    attr_reader :job_class
 
-  sig {returns(String)}
-  def generate_rbi
-    puts "-- Generate sigs for mailer #{@job_class.name} --"
+    sig { params(job_class: T.class_of(ActiveJob::Base)).void }
+    def initialize(job_class)
+      @job_class = T.let(job_class, T.class_of(ActiveJob::Base))
+      @rbi_generator = T.let(Parlour::RbiGenerator.new, Parlour::RbiGenerator)
+    end
 
-    @parlour.root.add_comments([
-      'This is an autogenerated file for Rails\' jobs.',
-      'Please rerun bundle exec rake rails_rbi:jobs to regenerate.'
-    ])
+    sig { void }
+    def populate_rbi
+      @rbi_generator.root.add_comment([
+        'This is an autogenerated file for Rails\' jobs.',
+        'Please rerun bundle exec rake rails_rbi:jobs to regenerate.'
+      ])
 
-    @parlour.root.create_class(@job_class.name) do |job_rbi|
-      method_def = @job_class.instance_method(:perform)
-      parameters = SorbetRails::SorbetUtils.parameters_from_method_def(method_def)
-      job_rbi.create_method(
-        "perform_later",
-        parameters: parameters,
-        class_method: true,
-      )
-      job_rbi.create_method(
-        "perform_now",
-        parameters: parameters,
-        class_method: true,
-      )
-      # Override the signature for "set" so that we can support it
-      # At run-time, this method returns a `ActiveJob::ConfiguredJob` but
-      # we fake the signature to return "T.self_class" so that
-      # sorbet can type-check when `perform_later` is called on it
-      # See: https://guides.rubyonrails.org/active_job_basics.html#enqueue-the-job
-      job_rbi.create_method(
-        "set",
-        # Documentation: https://api.rubyonrails.org/classes/ActiveJob/Core/ClassMethods.html
-        parameters: [
-          Parameter.new(
-            "wait:",
-            type: "T.nilable(ActiveSupport::Duration)",
-            default: "nil",
-          ),
-          Parameter.new(
-            "wait_until:",
-            type: "T.nilable(T.any(ActiveSupport::TimeWithZone, Date, Time))",
-            default: "nil",
-          ),
-          Parameter.new(
-            "queue:",
-            type: "T.nilable(T.any(String, Symbol))",
-            default: "nil",
-          ),
-          Parameter.new(
-            "priority:",
-            type: "T.nilable(Integer)",
-            default: "nil",
-          ),
-        ],
-        return_type: "T.self_type",
-        class_method: true,
-      )
+      @rbi_generator.root.create_class(T.must(@job_class.name)) do |job_rbi|
+        method_def = @job_class.instance_method(:perform)
+        parameters = SorbetRails::SorbetUtils.parameters_from_method_def(method_def)
+        job_rbi.create_method(
+          "perform_later",
+          parameters: parameters,
+          class_method: true,
+          return_type: @job_class.name,
+        )
+        job_rbi.create_method(
+          "perform_now",
+          parameters: parameters,
+          class_method: true,
+          return_type: @job_class.name,
+        )
+        # Override the signature for "set" so that we can support it
+        # At run-time, this method returns a `ActiveJob::ConfiguredJob` but
+        # we fake the signature to return "T.self_class" so that
+        # sorbet can type-check when `perform_later` is called on it
+        # See: https://guides.rubyonrails.org/active_job_basics.html#enqueue-the-job
+        job_rbi.create_method(
+          "set",
+          # Documentation: https://api.rubyonrails.org/classes/ActiveJob/Core/ClassMethods.html
+          parameters: [
+            Parameter.new(
+              "wait:",
+              type: "T.nilable(ActiveSupport::Duration)",
+              default: "nil",
+            ),
+            Parameter.new(
+              "wait_until:",
+              type: "T.nilable(T.any(ActiveSupport::TimeWithZone, Date, Time))",
+              default: "nil",
+            ),
+            Parameter.new(
+              "queue:",
+              type: "T.nilable(T.any(String, Symbol))",
+              default: "nil",
+            ),
+            Parameter.new(
+              "priority:",
+              type: "T.nilable(Integer)",
+              default: "nil",
+            ),
+          ],
+          return_type: "T.self_type",
+          class_method: true,
+        )
+      end
     end
 
-    @parlour.rbi
+    sig { returns(String) }
+    def generate_rbi
+      puts "-- Generate sigs for mailer #{@job_class.name} --"
+      populate_rbi
+      @rbi_generator.rbi
+    end
   end
 end