rubocop-sorbet 0.7.6 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bb19df178a322278126862ef69ee548a1480a3273b2fa7cb390efea682076d3
-  data.tar.gz: a4808b614e42b591e1254298ae40b41327b5762f5d7e494e5dbd476034d7f5a8
+  metadata.gz: 68f2d0d8c272caa3933e34350356e99c32e0ec42bec4b43a39c748ef2422d048
+  data.tar.gz: c0bd1e275d17d85ff1a6f63ab0bad42f47e5f3f17480ac4d06e5d70f4f52973d
 SHA512:
-  metadata.gz: 495f4c62a3e669483d4a2fb958672480e1f50519589bbef0efab007b32f56c32fad54a795a47ee8da6157d4595da0a50f845744578e0f44fab34e57fc67aa28e
-  data.tar.gz: 3e07de7f56533ed0c86dfb510e8efa0a3d1c9eb79cd130f24235cd6919a1f05ca88afc8fa7ae114de9de3ed49beac2ddc16d0d0c3e37a0a2bf6f7404ac80dcaa
+  metadata.gz: 8746cfe46cc7c1f7ecc6f4310c21a725b34172168de624a02485c890b5441948e26fc4617b488365a055fa3d44ee2193a5eb41ab0c4423d06d3cea8d058ccb55
+  data.tar.gz: e32a6b29d524cbb963c69ba8bb7bbb6b8535ac9793c0ff80db7817aa9ce751e4a6d82161f50a2942fd3a0c17e61c70954bf4406718430cb72167564963348452

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorbet (0.7.6)
+    rubocop-sorbet (0.7.8)
       rubocop (>= 0.90.0)
 
 GEM
@@ -54,7 +54,7 @@ GEM
     unparser (0.6.0)
       diff-lcs (~> 1.3)
       parser (>= 3.0.0)
-    yard (0.9.25)
+    yard (0.9.36)
 
 PLATFORMS
   ruby

data/README.md

@@ -69,6 +69,14 @@ inherit_gem:
 
 This will turn off default cops for `**/*.rbi` files and enable the RBI specific cops.
 
+You'll also need to add an entry to the main `.rubocop.yml` so that RBI files are included, e.g.:
+
+```yaml
+AllCops:
+  Include:
+    - "sorbet/rbi/shims/**/*.rbi"
+```
+
 ## The Cops
 All cops are located under [`lib/rubocop/cop/sorbet`](lib/rubocop/cop/sorbet), and contain examples/documentation.
 

data/config/default.yml

@@ -293,3 +293,8 @@ Sorbet/ValidSigil:
   - bin/**/*
   - db/**/*.rb
   - script/**/*
+
+Sorbet/VoidCheckedTests:
+  Description: 'Forbid `.void.checked(:tests)`'
+  Enabled: true
+  VersionAdded: 0.7.7

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

@@ -102,7 +102,7 @@ module RuboCop
         end
 
         class Property
-          attr_reader :node, :kind, :name, :type, :default, :factory
+          attr_reader :node, :kind, :name, :default, :factory
 
           def initialize(node, kind, name, type, default:, factory:)
             @node = node
@@ -151,6 +151,11 @@ module RuboCop
           def nilable?
             type.start_with?("T.nilable(")
           end
+
+          def type
+            copy = @type.gsub(/[[:space:]]+/, "").strip # Remove newlines and spaces
+            copy.gsub(",", ", ") # Add a space after each comma
+          end
         end
 
         # @!method t_struct?(node)
@@ -215,8 +220,35 @@ module RuboCop
           sorted_props = props.sort_by { |prop| prop.default || prop.factory || prop.nilable? ? 1 : 0 }
 
           string = +"\n"
-          string << "#{indent}sig { params(#{sorted_props.map(&:initialize_sig_param).join(", ")}).void }\n"
-          string << "#{indent}def initialize(#{sorted_props.map(&:initialize_param).join(", ")})\n"
+
+          line = "#{indent}sig { params(#{sorted_props.map(&:initialize_sig_param).join(", ")}).void }\n"
+          if line.length <= max_line_length
+            string << line
+          else
+            string << "#{indent}sig do\n"
+            string << "#{indent}  params(\n"
+            sorted_props.each do |prop|
+              string << "#{indent}    #{prop.initialize_sig_param}"
+              string << "," if prop != sorted_props.last
+              string << "\n"
+            end
+            string << "#{indent}  ).void\n"
+            string << "#{indent}end\n"
+          end
+
+          line = "#{indent}def initialize(#{sorted_props.map(&:initialize_param).join(", ")})\n"
+          if line.length <= max_line_length
+            string << line
+          else
+            string << "#{indent}def initialize(\n"
+            sorted_props.each do |prop|
+              string << "#{indent}  #{prop.initialize_param}"
+              string << "," if prop != sorted_props.last
+              string << "\n"
+            end
+            string << "#{indent})\n"
+          end
+
           props.each do |prop|
             string << "#{indent}  #{prop.initialize_assign}\n"
           end

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

@@ -23,11 +23,11 @@ module RuboCop
       #   # good
       #   sig { abstract.void }
       #
-      #  # bad
-      #  sig { returns(Integer).params(x: Integer) }
+      #   # bad
+      #   sig { returns(Integer).params(x: Integer) }
       #
-      #  # good
-      #  sig { params(x: Integer).returns(Integer) }
+      #   # good
+      #   sig { params(x: Integer).returns(Integer) }
       class SignatureBuildOrder < ::RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
         include SignatureHelp
 

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows the usage of `.void.checked(:tests)`.
+      #
+      # Using `.void` changes the value returned from the method, but only if
+      # runtime type checking is enabled for the method. Methods marked `.void`
+      # will return different values in tests compared with non-test
+      # environments. This is particularly troublesome if branching on the
+      # result of a `.void` method, because the returned value in test code
+      # will be the truthy `VOID` value, while the non-test return value may be
+      # falsy depending on the method's implementation.
+      #
+      # - Use `.returns(T.anything).checked(:tests)` to keep the runtime type
+      #   checking for the rest of the parameters.
+      # - Use `.void.checked(:never)` if you are on an older version of Sorbet
+      #   which does not have `T.anything` (meaning versions 0.5.10781 or
+      #   earlier. Versions released after 2023-04-14 include `T.anything`.)
+      #
+      # @example
+      #
+      #   # bad
+      #   sig { void.checked(:tests) }
+      #
+      #   # good
+      #   sig { void }
+      #   sig { returns(T.anything).checked(:tests) }
+      #   sig { void.checked(:never) }
+      class VoidCheckedTests < ::RuboCop::Cop::Base
+        include(RuboCop::Cop::RangeHelp)
+        include(RuboCop::Cop::Sorbet::SignatureHelp)
+        extend AutoCorrector
+
+        # @!method checked_tests(node)
+        def_node_search(:checked_tests, <<~PATTERN)
+          ({csend send} _ :checked (sym :tests))
+        PATTERN
+
+        MESSAGE =
+          "Returning `.void` from a sig marked `.checked(:tests)` means that the " \
+            "method will return a different value in non-test environments (possibly " \
+            "with different truthiness). Either use `.returns(T.anything).checked(:tests)` " \
+            "to keep checking in tests, or `.void.checked(:never)` to leave it untouched."
+        private_constant(:MESSAGE)
+
+        private def top_level_void(node)
+          return unless node.is_a?(RuboCop::AST::SendNode)
+
+          if node.method?(:void)
+            node
+          elsif (recv = node.receiver)
+            top_level_void(recv)
+          end
+        end
+
+        def on_signature(node)
+          checked_send = checked_tests(node).first
+          return unless checked_send
+
+          if (parent = node.parent) && (sibling_index = node.sibling_index)
+            later_siblings = parent.children[(sibling_index + 1)..]
+            if (def_node = later_siblings.find { |sibling| sibling.is_a?(RuboCop::AST::DefNode) })
+              # Sorbet requires that `initialize` methods return `.void`
+              # (A stylistic convention which happens to be enforced by Sorbet)
+              return if def_node.method?(:initialize)
+            end
+          end
+
+          void_send = top_level_void(node.body)
+
+          return unless void_send
+
+          add_offense(
+            void_send.selector,
+            message: MESSAGE,
+          ) do |corrector|
+            corrector.replace(void_send.selector, "returns(T.anything)")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet_cops.rb

@@ -26,6 +26,7 @@ require_relative "sorbet/rbi/single_line_rbi_class_module_definitions"
 
 require_relative "sorbet/signatures/allow_incompatible_override"
 require_relative "sorbet/signatures/checked_true_in_signature"
+require_relative "sorbet/signatures/void_checked_tests"
 require_relative "sorbet/signatures/keyword_argument_ordering"
 require_relative "sorbet/signatures/signature_build_order"
 require_relative "sorbet/signatures/enforce_signatures"

data/lib/rubocop/sorbet/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sorbet
-    VERSION = "0.7.6"
+    VERSION = "0.7.8"
   end
 end

data/manual/cops.md

@@ -39,6 +39,7 @@ In the following section you find all available cops:
 * [Sorbet/TrueSigil](cops_sorbet.md#sorbettruesigil)
 * [Sorbet/TypeAliasName](cops_sorbet.md#sorbettypealiasname)
 * [Sorbet/ValidSigil](cops_sorbet.md#sorbetvalidsigil)
+* [Sorbet/VoidCheckedTests](cops_sorbet.md#sorbetvoidcheckedtests)
 
 <!-- END_COP_LIST -->
 

data/manual/cops_sorbet.md

@@ -740,12 +740,6 @@ Checks for the correct order of sig builder methods:
 - returns, or void
 - soft, checked, or on_failure
 
- # bad
- sig { returns(Integer).params(x: Integer) }
-
- # good
- sig { params(x: Integer).returns(Integer) }
-
 ### Examples
 
 ```ruby
@@ -754,6 +748,12 @@ sig { void.abstract }
 
 # good
 sig { abstract.void }
+
+# bad
+sig { returns(Integer).params(x: Integer) }
+
+# good
+sig { params(x: Integer).returns(Integer) }
 ```
 
 ## Sorbet/SingleLineRbiClassModuleDefinitions
@@ -884,3 +884,37 @@ MinimumStrictness | `nil` | String
 ExactStrictness | `nil` | String
 Include | `**/*.{rb,rbi,rake,ru}` | Array
 Exclude | `bin/**/*`, `db/**/*.rb`, `script/**/*` | Array
+
+## Sorbet/VoidCheckedTests
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.7.7 | -
+
+Disallows the usage of `.void.checked(:tests)`.
+
+Using `.void` changes the value returned from the method, but only if
+runtime type checking is enabled for the method. Methods marked `.void`
+will return different values in tests compared with non-test
+environments. This is particularly troublesome if branching on the
+result of a `.void` method, because the returned value in test code
+will be the truthy `VOID` value, while the non-test return value may be
+falsy depending on the method's implementation.
+
+- Use `.returns(T.anything).checked(:tests)` to keep the runtime type
+  checking for the rest of the parameters.
+- Use `.void.checked(:never)` if you are on an older version of Sorbet
+  which does not have `T.anything` (meaning versions 0.5.10781 or
+  earlier. Versions released after 2023-04-14 include `T.anything`.)
+
+### Examples
+
+```ruby
+# bad
+sig { void.checked(:tests) }
+
+# good
+sig { void }
+sig { returns(T.anything).checked(:tests) }
+sig { void.checked(:never) }
+```

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.7.8
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-04 00:00:00.000000000 Z
+date: 2024-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -122,6 +122,7 @@ files:
 - lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb
 - lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb
 - lib/rubocop/cop/sorbet/signatures/signature_build_order.rb
+- lib/rubocop/cop/sorbet/signatures/void_checked_tests.rb
 - lib/rubocop/cop/sorbet/type_alias_name.rb
 - lib/rubocop/cop/sorbet_cops.rb
 - lib/rubocop/sorbet.rb
@@ -155,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: Automatic Sorbet code style checking tool.