rubocop-sorbet 0.10.2 → 0.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39f455b224ebfe0ed1167d4f65df45ba786f5605e7571c81775235563c2d964a
-  data.tar.gz: f0b2762513b7ee13abf3e2ad63222e796df11692f837530af59285802a54389c
+  metadata.gz: a9ebae9ccd4d5ac64cdcede02bbad10ffe8bd68b31a99d2e3c2914de447dae24
+  data.tar.gz: bbf3c32b940424369bde19fabcd6ec5cab543c265ce810d288a947dbae1d7ea7
 SHA512:
-  metadata.gz: 1407c352354c7dcc548f0e6f2a031ba214627e09c766fd67665f0c47973232bbe406cff70a1a6c6178494bbacee41fcdc0ace83a2c987c7220cdd9e494384bbe
-  data.tar.gz: 6df2c39e491354b98265115b646ed149bf84b127d28057a0eac05714ed45312377d2fc454945c3e602817b44b46d805c9572affa68d4f04429ef3635faf9663c
+  metadata.gz: 5cd6ef4d4435d430c26ed33d4267de84fb962fff6d564083428fb3153e7c0486cebe4791080dd22d6312acc8faa8b4154642c5c2eee69d80f5cdde927bacf520
+  data.tar.gz: 1eedabd82415a5c626eb33e297772ffb057d322b298e6504c63437918154e624e2c39c1667a99b703a0d642a9c840f01805a2878349165e16d72720d4656db4b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorbet (0.10.2)
+    rubocop-sorbet (0.10.3)
       lint_roller
       rubocop (>= 1.75.2)
 
@@ -39,7 +39,7 @@ GEM
     regexp_parser (2.10.0)
     reline (0.6.0)
       io-console (~> 0.5)
-    rubocop (1.75.8)
+    rubocop (1.76.0)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -47,17 +47,17 @@ GEM
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.44.0, < 2.0)
+      rubocop-ast (>= 1.45.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.44.1)
+    rubocop-ast (1.45.1)
       parser (>= 3.3.7.2)
       prism (~> 1.4)
     rubocop-minitest (0.38.1)
       lint_roller (~> 1.1)
       rubocop (>= 1.75.0, < 2.0)
       rubocop-ast (>= 1.38.0, < 2.0)
-    rubocop-shopify (2.17.0)
+    rubocop-shopify (2.17.1)
       rubocop (~> 1.62)
     ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)

data/Rakefile

@@ -60,10 +60,10 @@ module Releaser
 
     sh "git add lib/rubocop/sorbet/version.rb config/default.yml Gemfile.lock VERSION manual"
 
-    puts "git commit -m 'Release #{version}'"
-    puts "git push origin main"
-    puts "git tag -a v#{version} -m 'Release #{version}'"
-    puts "git push origin v#{version}"
+    sh "git commit -m 'Release v#{version}'"
+    sh "git push origin main"
+    sh "git tag -a v#{version} -m 'Release v#{version}'"
+    sh "git push origin v#{version}"
   end
 
   private

data/VERSION

@@ -1 +1 @@
-0.10.2
+0.10.3

data/config/default.yml

@@ -23,6 +23,7 @@ Sorbet/BlockMethodDefinition:
   Safe: true
   SafeAutoCorrect: false
   VersionAdded: '0.10.1'
+  VersionChanged: '0.10.3'
 
 Sorbet/BuggyObsoleteStrictMemoization:
   Description: >-
@@ -47,6 +48,12 @@ Sorbet/CallbackConditionalsBinding:
   Safe: false
   VersionAdded: 0.7.0
 
+Sorbet/CapitalizedTypeParameters:
+  Description: 'Ensures that type parameters are capitalized.'
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: '0.10.3'
+
 Sorbet/CheckedTrueInSignature:
   Description: 'Disallows the usage of `checked(true)` in signatures.'
   Enabled: true

data/lib/rubocop/cop/sorbet/block_method_definition.rb

@@ -10,7 +10,8 @@ module RuboCop
       #
       # The one exception is for `Class.new` blocks, as long as the result is
       # assigned to a constant (i.e. as long as it is not an anonymous class).
-
+      # Another exception is for ActiveSupport::Concern `class_methods` blocks.
+      #
       # @example
       #   # bad
       #   yielding_method do
@@ -40,17 +41,50 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   module SomeConcern
+      #     extend ActiveSupport::Concern
+      #
+      #     class_methods do
+      #       def good(args)
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
       class BlockMethodDefinition < Base
         include RuboCop::Cop::Alignment
         extend AutoCorrector
 
         MSG = "Do not define methods in blocks (use `define_method` as a workaround)."
 
+        # @!method activesupport_concern_class_methods_block?(node)
+        def_node_matcher :activesupport_concern_class_methods_block?, <<~PATTERN
+          (block
+            (send nil? :class_methods)
+            _
+            _
+          )
+        PATTERN
+
+        # @!method module_extends_activesupport_concern?(node)
+        def_node_matcher :module_extends_activesupport_concern?, <<~PATTERN
+          (module _
+            (begin
+              <(send nil? :extend (const (const {nil? cbase} :ActiveSupport) :Concern)) ...>
+              ...
+            )
+          )
+        PATTERN
+
         def on_block(node)
           if (parent = node.parent)
             return if parent.casgn_type?
           end
 
+          # Check if this is a class_methods block inside an ActiveSupport::Concern
+          return if in_activesupport_concern_class_methods_block?(node)
+
           node.each_descendant(:any_def) do |def_node|
             add_offense(def_node) do |corrector|
               autocorrect_method_in_block(corrector, def_node)
@@ -61,21 +95,108 @@ module RuboCop
 
         private
 
+        def in_activesupport_concern_class_methods_block?(node)
+          return false unless activesupport_concern_class_methods_block?(node)
+
+          immediate_module = node.each_ancestor(:module).first
+
+          module_extends_activesupport_concern?(immediate_module)
+        end
+
         def autocorrect_method_in_block(corrector, node)
           indent = offset(node)
 
           method_name = node.method_name
-          args = node.arguments.map(&:source).join(", ")
-          body = node.body&.source&.prepend("\n#{indent}  ")
+          args = transform_args_to_block_args(node)
 
+          # Build the method signature replacement
           if node.def_type?
-            replacement = "define_method(:#{method_name}) do |#{args}|#{body}\n#{indent}end"
+            signature_replacement = "define_method(:#{method_name}) do#{args}"
           elsif node.defs_type?
             receiver = node.receiver.source
-            replacement = "#{receiver}.define_singleton_method(:#{method_name}) do |#{args}|#{body}\n#{indent}end"
+            signature_replacement = "#{receiver}.define_singleton_method(:#{method_name}) do#{args}"
+          end
+
+          if node.body
+            end_pos = node.body.source_range.begin_pos
+            indentation = "\n#{indent}  "
+          else
+            end_pos, indentation = handle_method_without_body(node, indent)
           end
 
-          corrector.replace(node, replacement)
+          signature_range = node.source_range.with(end_pos: end_pos)
+
+          corrector.replace(signature_range, signature_replacement + indentation)
+        end
+
+        def transform_args_to_block_args(node)
+          args = node.arguments
+
+          if args.empty?
+            ""
+          else
+            args_string = args.map(&:source).join(", ")
+            " |#{args_string}|"
+          end
+        end
+
+        def handle_method_without_body(node, indent)
+          if single_line_method?(node)
+            handle_single_line_method(node, indent)
+          else
+            handle_multiline_method_without_body(node)
+          end
+        end
+
+        def single_line_method?(node)
+          !node.source.include?("\n")
+        end
+
+        def handle_single_line_method(node, indent)
+          end_pos = node.source_range.end_pos
+          indentation = "\n#{indent}end"
+          [end_pos, indentation]
+        end
+
+        def handle_multiline_method_without_body(node)
+          end_pos = find_method_signature_end_position(node)
+          indentation = ""
+          [end_pos, indentation]
+        end
+
+        def find_method_signature_end_position(node)
+          if node.arguments.any?
+            find_end_position_with_arguments(node)
+          else
+            find_end_position_without_arguments(node)
+          end
+        end
+
+        def find_end_position_with_arguments(node)
+          last_arg = node.last_argument
+          end_pos = last_arg.source_range.end_pos
+
+          adjust_for_closing_parenthesis(end_pos)
+        end
+
+        def find_end_position_without_arguments(node)
+          node.loc.name.end_pos
+        end
+
+        def adjust_for_closing_parenthesis(end_pos)
+          source_after_last_arg = processed_source.buffer.source[end_pos..-1]
+
+          match = closing_parenthesis_follows(source_after_last_arg)
+
+          if match
+            end_pos + match.end(0)
+          else
+            end_pos
+          end
+        end
+
+        def closing_parenthesis_follows(source)
+          source.match(/\A\s*\)/)
         end
       end
     end

data/lib/rubocop/cop/sorbet/signatures/capitalized_type_parameters.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Ensure type parameters used in generic methods are always capitalized.
+      #
+      # @example
+      #
+      #   # bad
+      #   sig { type_parameters(:x).params(a: T.type_parameter(:x)).void }
+      #   def foo(a); end
+      #
+      #   # good
+      #   sig { type_parameters(:X).params(a: T.type_parameter(:X)).void }
+      #   def foo(a: 1); end
+      class CapitalizedTypeParameters < ::RuboCop::Cop::Base
+        extend AutoCorrector
+        include SignatureHelp
+
+        MSG = "Type parameters must be capitalized."
+
+        RESTRICT_ON_SEND = [:type_parameter].freeze
+
+        # @!method type_parameters?(node)
+        def_node_matcher(:type_parameters?, <<-PATTERN)
+          (send nil? :type_parameters ...)
+        PATTERN
+
+        # @!method t_type_parameter?(node)
+        def_node_matcher(:t_type_parameter?, <<-PATTERN)
+          (send (const {nil? | cbase} :T) :type_parameter ...)
+        PATTERN
+
+        def on_signature(node)
+          send = node.children[2]
+
+          while send&.send_type?
+            if type_parameters?(send)
+              check_type_parameters_case(send)
+            end
+
+            send = send.children[0]
+          end
+        end
+
+        def on_send(node)
+          check_type_parameters_case(node) if t_type_parameter?(node)
+        end
+
+        def on_csend(node)
+          check_type_parameters_case(node) if t_type_parameter?(node)
+        end
+
+        private
+
+        def check_type_parameters_case(node)
+          node.children[2..].each do |arg|
+            next unless arg.is_a?(RuboCop::AST::SymbolNode)
+            next if arg.value =~ /^[A-Z]/
+
+            add_offense(arg) do |corrector|
+              corrector.replace(arg, arg.value.capitalize.to_sym.inspect)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet_cops.rb

@@ -33,6 +33,7 @@ require_relative "sorbet/rbi_versioning/gem_version_annotation_helper"
 require_relative "sorbet/rbi_versioning/valid_gem_version_annotations"
 
 require_relative "sorbet/signatures/allow_incompatible_override"
+require_relative "sorbet/signatures/capitalized_type_parameters"
 require_relative "sorbet/signatures/checked_true_in_signature"
 require_relative "sorbet/signatures/empty_line_after_sig"
 require_relative "sorbet/signatures/enforce_signatures"

data/lib/rubocop/sorbet/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sorbet
-    VERSION = "0.10.2"
+    VERSION = "0.10.3"
   end
 end

data/manual/cops.md

@@ -10,6 +10,7 @@ In the following section you find all available cops:
 * [Sorbet/BlockMethodDefinition](cops_sorbet.md#sorbetblockmethoddefinition)
 * [Sorbet/BuggyObsoleteStrictMemoization](cops_sorbet.md#sorbetbuggyobsoletestrictmemoization)
 * [Sorbet/CallbackConditionalsBinding](cops_sorbet.md#sorbetcallbackconditionalsbinding)
+* [Sorbet/CapitalizedTypeParameters](cops_sorbet.md#sorbetcapitalizedtypeparameters)
 * [Sorbet/CheckedTrueInSignature](cops_sorbet.md#sorbetcheckedtrueinsignature)
 * [Sorbet/ConstantsFromStrings](cops_sorbet.md#sorbetconstantsfromstrings)
 * [Sorbet/EmptyLineAfterSig](cops_sorbet.md#sorbetemptylineaftersig)

data/manual/cops_sorbet.md

@@ -45,9 +45,16 @@ FooOrBar = T.type_alias { T.any(Foo, Bar) }
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Enabled | Yes | Yes (Unsafe) | 0.10.1 | -
+Enabled | Yes | Yes (Unsafe) | 0.10.1 | 0.10.3
 
+Disallow defining methods in blocks, to prevent running into issues
+caused by https://github.com/sorbet/sorbet/issues/3609.
 
+As a workaround, use `define_method` instead.
+
+The one exception is for `Class.new` blocks, as long as the result is
+assigned to a constant (i.e. as long as it is not an anonymous class).
+Another exception is for ActiveSupport::Concern `class_methods` blocks.
 
 ### Examples
 
@@ -79,6 +86,17 @@ MyClass = Class.new do
     # ...
   end
 end
+
+# good
+module SomeConcern
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def good(args)
+      # ...
+    end
+  end
+end
 ```
 
 ## Sorbet/BuggyObsoleteStrictMemoization
@@ -157,6 +175,26 @@ class Post < ApplicationRecord
 end
 ```
 
+## Sorbet/CapitalizedTypeParameters
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes (Unsafe) | 0.10.3 | -
+
+Ensure type parameters used in generic methods are always capitalized.
+
+### Examples
+
+```ruby
+# bad
+sig { type_parameters(:x).params(a: T.type_parameter(:x)).void }
+def foo(a); end
+
+# good
+sig { type_parameters(:X).params(a: T.type_parameter(:X)).void }
+def foo(a: 1); end
+```
+
 ## Sorbet/CheckedTrueInSignature
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.3
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -114,6 +114,7 @@ files:
 - lib/rubocop/cop/sorbet/sigils/true_sigil.rb
 - lib/rubocop/cop/sorbet/sigils/valid_sigil.rb
 - lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb
+- lib/rubocop/cop/sorbet/signatures/capitalized_type_parameters.rb
 - lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb
 - lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb
 - lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb