rubocop-sorbet 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed85b2aa8c9315734700e66a95850b31448f0564044857f05a8b9ffcaaa8bd69
-  data.tar.gz: 29fbbd4eef2a6039dd1f15247d6a39c05575de00cfd3a9ec2b8a3e5258628f27
+  metadata.gz: b80b70b68c03033dcda68e2661cba6ccbe10c647618cbf6068175c635288f7e4
+  data.tar.gz: 794956ee0b9ca5301f680fd79d3d414551284bce1f8dc218e1980da204b13689
 SHA512:
-  metadata.gz: a69d768ccb20841020b531c5befae05d4279b7483e26c266f61214d8702fdb67419187db6ff8f9a8bd8973113aa9861e9ef9f0295a4157397023f6e8d6cdeaab
-  data.tar.gz: 3c2afa2c95472039e4c95bd81ffa91847a05f0114690d5e89bb5d34f4ad4d303aff4df81e107dcc79c3de146b35834bf8ca5c94595c90b5d2b6d4c1e096bb5e2
+  metadata.gz: d5f81c72e557eb0888383137198f6138a52b9e043e4d2e02857419658a34407cf90bf08d4fc662fdd4ac9b0c10771aa79876dce08ded2ca61a8b2bea0561dad3
+  data.tar.gz: 5f8926ae82a56c9edf3fde4552d3ef84b942dbb1f317ecf603ac32b39fc08acc1bef5d8ed459ab28513b667ed901617510a72a3bf34cf8ea7b4d2ffba1ab982a

data/Gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in rubocop-sorbet.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
+gem "rake", ">= 12.3.3"
 gem "rspec"
 gem "rubocop-shopify", require: false
 gem "yard", "~> 0.9"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorbet (0.4.0)
+    rubocop-sorbet (0.6.1)
       rubocop
 
 GEM
@@ -25,7 +25,7 @@ GEM
       ast (~> 2.4.0)
     procto (0.0.3)
     rainbow (3.0.0)
-    rake (12.3.2)
+    rake (13.0.1)
     regexp_parser (1.7.0)
     rexml (3.2.4)
     rspec (3.8.0)
@@ -71,7 +71,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  rake (~> 12.0)
+  rake (>= 12.3.3)
   rspec
   rubocop-shopify
   rubocop-sorbet!

data/config/default.yml

@@ -53,15 +53,26 @@ Sorbet/FalseSigil:
   - db/**/*.rb
   - script/**/*
 
+Sorbet/ForbidExtendTSigHelpersInShims:
+  Description: 'Forbid the use of `extend T::Sig` and `extend T::Helpers` in RBI shims'
+  Enabled: true
+  VersionAdded: '0.6.0'
+  Include:
+  - "**/*.rbi"
+
 Sorbet/ForbidIncludeConstLiteral:
   Description: 'Forbids include of non-literal constants.'
-  Enabled: true
+  Enabled: false
   VersionAdded: 0.2.0
+  VersionChanged: 0.5.0
 
 Sorbet/ForbidSuperclassConstLiteral:
   Description: 'Forbid superclasses which are non-literal constants.'
-  Enabled: true
+  Enabled: false
   VersionAdded: 0.2.0
+  VersionChanged: 0.6.1
+  Exclude:
+  - db/migrate/*.rb
 
 Sorbet/ForbidUntypedStructProps:
   Description: >-
@@ -90,6 +101,11 @@ Sorbet/KeywordArgumentOrdering:
   Enabled: true
   VersionAdded: 0.2.0
 
+Sorbet/OneAncestorPerLine:
+  Description: 'Enforces one ancestor per call to requires_ancestor'
+  Enabled: false
+  VersionAdded: '0.6.0'
+
 Sorbet/ParametersOrderingInSignature:
   Description: 'Enforces same parameter order between a method and its signature.'
   Enabled: true
@@ -105,6 +121,13 @@ Sorbet/SignatureBuildOrder:
   Enabled: true
   VersionAdded: 0.3.0
 
+Sorbet/SingleLineRbiClassModuleDefinitions:
+  Description: 'Empty class and module definitions in RBI must be on a single line.'
+  Enabled: false
+  VersionAdded: '0.6.0'
+  Include:
+  - "**/*.rbi"
+
 Sorbet/StrictSigil:
   Description: 'All files must be at least at strictness `strict`.'
   Enabled: false

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

@@ -17,7 +17,7 @@ module RuboCop
       #   FooOrBar = T.type_alias { T.any(Foo, Bar) }
       class BindingConstantWithoutTypeAlias < RuboCop::Cop::Cop
         def_node_matcher(:binding_unaliased_type?, <<-PATTERN)
-          (casgn _ _ [#not_nil? #not_t_let? #method_needing_aliasing_on_t?])
+          (casgn _ _ [#not_nil? #not_t_let? #not_dynamic_type_creation_with_block? #not_generic_parameter_decl? #method_needing_aliasing_on_t?])
         PATTERN
 
         def_node_matcher(:using_type_alias?, <<-PATTERN)
@@ -48,6 +48,21 @@ module RuboCop
           )
         PATTERN
 
+        def_node_matcher(:dynamic_type_creation_with_block?, <<-PATTERN)
+          (block
+            (send
+              const :new ...)
+              _
+              _
+          )
+        PATTERN
+
+        def_node_matcher(:generic_parameter_decl?, <<-PATTERN)
+          (
+            send nil? {:type_template :type_member} ...
+          )
+        PATTERN
+
         def_node_search(:method_needing_aliasing_on_t?, <<-PATTERN)
           (
             send
@@ -61,6 +76,14 @@ module RuboCop
           !t_let?(node)
         end
 
+        def not_dynamic_type_creation_with_block?(node)
+          !dynamic_type_creation_with_block?(node)
+        end
+
+        def not_generic_parameter_decl?(node)
+          !generic_parameter_decl?(node)
+        end
+
         def not_nil?(node)
           !node.nil?
         end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop ensures RBI shims do not include a call to extend T::Sig
+      # or to extend T::Helpers
+      #
+      # @example
+      #
+      #   # bad
+      #   module SomeModule
+      #     extend T::Sig
+      #     extend T::Helpers
+      #
+      #     sig { returns(String) }
+      #     def foo; end
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     sig { returns(String) }
+      #     def foo; end
+      #   end
+      class ForbidExtendTSigHelpersInShims < RuboCop::Cop::Cop
+        include RangeHelp
+
+        MSG = 'Extending T::Sig or T::Helpers in a shim is unnecessary'
+        RESTRICT_ON_SEND = [:extend]
+
+        def_node_matcher :extend_t_sig?, <<~PATTERN
+          (send nil? :extend (const (const nil? :T) :Sig))
+        PATTERN
+
+        def_node_matcher :extend_t_helpers?, <<~PATTERN
+          (send nil? :extend (const (const nil? :T) :Helpers))
+        PATTERN
+
+        def autocorrect(node)
+          -> (corrector) do
+            corrector.remove(
+              range_by_whole_lines(node.source_range, include_final_newline: true)
+            )
+          end
+        end
+
+        def on_send(node)
+          add_offense(node) if extend_t_helpers?(node) || extend_t_sig?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -14,15 +14,6 @@ require 'rubocop'
 # end
 # ```
 #
-# This cop replaces them by:
-#
-# ```ruby
-# class MyClass
-#   MyClassInclude = send_expr
-#   include MyClassInclude
-# end
-# ```
-#
 # Multiple occurences of this can be found in Shopify's code base like:
 #
 # ```ruby
@@ -61,37 +52,6 @@ module RuboCop
           return unless [:module, :class, :sclass].include?(parent.type)
           add_offense(node)
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            # Find parent class node
-            parent = node.parent
-            parent = parent.parent if parent.type == :begin
-
-            # Build include variable name
-            class_name = (parent.child_nodes.first.const_name || 'Anon').split('::').last
-            include_name = find_free_name("#{class_name}Include")
-            used_names << include_name
-
-            # Apply fix
-            indent = ' ' * node.loc.column
-            fix = "#{include_name} = #{node.child_nodes.first.source}\n#{indent}"
-            corrector.insert_before(node.loc.expression, fix)
-            corrector.replace(node.child_nodes.first.loc.expression, include_name)
-          end
-        end
-
-        # Find a free local variable name
-        #
-        # Since each include uses its own local variable to store the send result,
-        # we need to ensure that we don't use the same name twice in the same
-        # module.
-        def find_free_name(base_name)
-          return base_name unless used_names.include?(base_name)
-          i = 2
-          i += 1 while used_names.include?("#{base_name}#{i}")
-          "#{base_name}#{i}"
-        end
       end
     end
   end

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

@@ -12,13 +12,6 @@ require 'rubocop'
 # class Foo < send_expr; end
 # ```
 #
-# This cop replaces them by:
-#
-# ```ruby
-# FooParent = send_expr
-# class Foo < FooParent; end
-# ```
-#
 # Multiple occurences of this can be found in Shopify's code base like:
 #
 # ```ruby
@@ -46,16 +39,6 @@ module RuboCop
           return unless not_lit_const_superclass?(node)
           add_offense(node.child_nodes[1])
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            class_name = node.parent.child_nodes.first.const_name
-            parent_name = "#{class_name}Parent"
-            indent = ' ' * node.parent.loc.column
-            corrector.insert_before(node.parent.loc.expression, "#{parent_name} = #{node.source}\n#{indent}")
-            corrector.replace(node.loc.expression, parent_name)
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop ensures one ancestor per requires_ancestor line
+      # rather than chaining them as a comma-separated list.
+      #
+      # @example
+      #
+      #   # bad
+      #   module SomeModule
+      #     requires_ancestor Kernel, Minitest::Assertions
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     requires_ancestor Kernel
+      #     requires_ancestor Minitest::Assertions
+      #   end
+      class OneAncestorPerLine < RuboCop::Cop::Cop
+        MSG = 'Cannot require more than one ancestor per line'
+
+        def_node_search :requires_ancestors, <<~PATTERN
+          (send nil? :requires_ancestor ...)
+        PATTERN
+
+        def_node_matcher :more_than_one_ancestor, <<~PATTERN
+          (send nil? :requires_ancestor const const+)
+        PATTERN
+
+        def_node_search :abstract?, <<~PATTERN
+          (send nil? :abstract!)
+        PATTERN
+
+        def on_module(node)
+          return unless node.body
+          return unless requires_ancestors(node)
+          process_node(node)
+        end
+
+        def on_class(node)
+          return unless abstract?(node)
+          return unless requires_ancestors(node)
+          process_node(node)
+        end
+
+        def autocorrect(node)
+          -> (corrector) do
+            ra_call = node.parent
+            split_ra_calls = ra_call.source.gsub(/,\s+/, new_ra_line(ra_call.loc.column))
+            corrector.replace(ra_call, split_ra_calls)
+          end
+        end
+
+        private
+
+        def process_node(node)
+          requires_ancestors(node).each do |ra|
+            add_offense(ra.child_nodes[1]) if more_than_one_ancestor(ra)
+          end
+        end
+
+        def new_ra_line(indent_count)
+          indents = " " * indent_count
+          indented_ra_call = "#{indents}requires_ancestor "
+          "\n#{indented_ra_call}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb

@@ -28,6 +28,8 @@ module RuboCop
       # Only `typed`, `(en)?coding`, `warn_indent` and `frozen_string_literal` magic comments are considered,
       # other comments or magic comments are left in the same place.
       class EnforceSigilOrder < ValidSigil
+        include RangeHelp
+
         def investigate(processed_source)
           return if processed_source.tokens.empty?
 
@@ -49,6 +51,14 @@ module RuboCop
             tokens.each_with_index do |token, index|
               corrector.replace(token.pos, expected[index].text)
             end
+
+            # Remove blank lines between the magic comments
+            lines = tokens.map(&:line).to_set
+            (lines.min...lines.max).each do |line|
+              next if lines.include?(line)
+              next unless processed_source[line - 1].empty?
+              corrector.remove(source_range(processed_source.buffer, line, 0))
+            end
           end
         end
 

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

@@ -27,6 +27,11 @@ module RuboCop
       # * `ParameterTypePlaceholder`: placeholders used for parameter types (default: 'T.untyped')
       # * `ReturnTypePlaceholder`: placeholders used for return types (default: 'T.untyped')
       class EnforceSignatures < SignatureCop
+        def initialize(config = nil, options = nil)
+          super(config, options)
+          @last_sig_for_scope = {}
+        end
+
         def_node_matcher(:accessor?, <<-PATTERN)
           (send nil? {:attr_reader :attr_writer :attr_accessor} ...)
         PATTERN
@@ -40,8 +45,11 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless accessor?(node)
-          check_node(node)
+          check_node(node) if accessor?(node)
+        end
+
+        def on_block(node)
+          @last_sig_for_scope[scope(node)] = node if signature?(node)
         end
 
         def autocorrect(node)
@@ -63,22 +71,23 @@ module RuboCop
           end
         end
 
+        def scope(node)
+          return nil unless node.parent
+          return node.parent if [:begin, :block, :class, :module].include?(node.parent.type)
+          scope(node.parent)
+        end
+
         private
 
         def check_node(node)
-          prev = previous_node(node)
-          unless signature?(prev)
+          scope = self.scope(node)
+          unless @last_sig_for_scope[scope]
             add_offense(
               node,
               message: "Each method is required to have a signature."
             )
           end
-        end
-
-        def previous_node(node)
-          parent = node.parent
-          return nil unless parent
-          parent.children[node.sibling_index - 1]
+          @last_sig_for_scope[scope] = nil
         end
 
         def param_type_placeholder

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

@@ -55,9 +55,9 @@ module RuboCop
           return nil unless can_autocorrect?
 
           lambda do |corrector|
-            nodes = call_chain(node).sort_by { |call| ORDER[call.method_name] }
-            tree =
-              nodes.reduce(nil) do |receiver, caller|
+            tree = call_chain(node_reparsed_with_modern_features(node))
+              .sort_by { |call| ORDER[call.method_name] }
+              .reduce(nil) do |receiver, caller|
                 caller.updated(nil, [receiver] + caller.children.drop(1))
               end
 
@@ -68,8 +68,27 @@ module RuboCop
           end
         end
 
+        # Create a subclass of AST Builder that has modern features turned on
+        class ModernBuilder < RuboCop::AST::Builder
+          modernize
+        end
+        private_constant :ModernBuilder
+
         private
 
+        # This method exists to reparse the current node with modern features enabled.
+        # Modern features include "index send" emitting, which is necessary to unparse
+        # "index sends" (i.e. `[]` calls) back to index accessors (i.e. as `foo[bar]``).
+        # Otherwise, we would get the unparsed node as `foo.[](bar)`.
+        def node_reparsed_with_modern_features(node)
+          # Create a new parser with a modern builder class instance
+          parser = Parser::CurrentRuby.new(ModernBuilder.new)
+          # Create a new source buffer with the node source
+          buffer = Parser::Source::Buffer.new(processed_source.path, source: node.source)
+          # Re-parse the buffer
+          parser.parse(buffer)
+        end
+
         def can_autocorrect?
           defined?(::Unparser)
         end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop ensures empty class/module definitions in RBI files are
+      # done on a single line rather than being split across multiple lines.
+      #
+      # @example
+      #
+      #   # bad
+      #   module SomeModule
+      #   end
+      #
+      #   # good
+      #   module SomeModule; end
+      class SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Cop
+        MSG = 'Empty class/module definitions in RBI files should be on a single line.'
+
+        def on_module(node)
+          process_node(node)
+        end
+
+        def on_class(node)
+          process_node(node)
+        end
+
+        def autocorrect(node)
+          -> (corrector) { corrector.replace(node, convert_newlines(node.source)) }
+        end
+
+        protected
+
+        def convert_newlines(source)
+          source.sub(/[\r\n]+\s*[\r\n]*/, "; ")
+        end
+
+        def process_node(node)
+          return if node.body
+          return if node.single_line?
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet_cops.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 require_relative 'sorbet/binding_constants_without_type_alias'
 require_relative 'sorbet/constants_from_strings'
+require_relative 'sorbet/forbid_extend_t_sig_helpers_in_shims'
 require_relative 'sorbet/forbid_superclass_const_literal'
 require_relative 'sorbet/forbid_include_const_literal'
 require_relative 'sorbet/forbid_untyped_struct_props'
+require_relative 'sorbet/single_line_rbi_class_module_definitions'
+require_relative 'sorbet/one_ancestor_per_line'
 
 require_relative 'sorbet/signatures/allow_incompatible_override'
 require_relative 'sorbet/signatures/checked_true_in_signature'

data/lib/rubocop/sorbet/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module RuboCop
   module Sorbet
-    VERSION = "0.4.0"
+    VERSION = "0.6.1"
   end
 end

data/manual/cops.md

@@ -12,15 +12,18 @@ In the following section you find all available cops:
 * [Sorbet/EnforceSigilOrder](cops_sorbet.md#sorbetenforcesigilorder)
 * [Sorbet/EnforceSignatures](cops_sorbet.md#sorbetenforcesignatures)
 * [Sorbet/FalseSigil](cops_sorbet.md#sorbetfalsesigil)
+* [Sorbet/ForbidExtendTSigHelpersInShims](cops_sorbet.md#sorbetforbidextendtsighelpersinshims)
 * [Sorbet/ForbidIncludeConstLiteral](cops_sorbet.md#sorbetforbidincludeconstliteral)
 * [Sorbet/ForbidSuperclassConstLiteral](cops_sorbet.md#sorbetforbidsuperclassconstliteral)
 * [Sorbet/ForbidUntypedStructProps](cops_sorbet.md#sorbetforbiduntypedstructprops)
 * [Sorbet/HasSigil](cops_sorbet.md#sorbethassigil)
 * [Sorbet/IgnoreSigil](cops_sorbet.md#sorbetignoresigil)
 * [Sorbet/KeywordArgumentOrdering](cops_sorbet.md#sorbetkeywordargumentordering)
+* [Sorbet/OneAncestorPerLine](cops_sorbet.md#sorbetoneancestorperline)
 * [Sorbet/ParametersOrderingInSignature](cops_sorbet.md#sorbetparametersorderinginsignature)
 * [Sorbet/SignatureBuildOrder](cops_sorbet.md#sorbetsignaturebuildorder)
 * [Sorbet/SignatureCop](cops_sorbet.md#sorbetsignaturecop)
+* [Sorbet/SingleLineRbiClassModuleDefinitions](cops_sorbet.md#sorbetsinglelinerbiclassmoduledefinitions)
 * [Sorbet/StrictSigil](cops_sorbet.md#sorbetstrictsigil)
 * [Sorbet/StrongSigil](cops_sorbet.md#sorbetstrongsigil)
 * [Sorbet/TrueSigil](cops_sorbet.md#sorbettruesigil)

data/manual/cops_sorbet.md

@@ -171,11 +171,45 @@ SuggestedStrictness | `true` | Boolean
 Include | `**/*.rb`, `**/*.rbi`, `**/*.rake`, `**/*.ru` | Array
 Exclude | `bin/**/*`, `db/**/*.rb`, `script/**/*` | Array
 
+## Sorbet/ForbidExtendTSigHelpersInShims
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.6.0 | -
+
+This cop ensures RBI shims do not include a call to extend T::Sig
+or to extend T::Helpers
+
+### Examples
+
+```ruby
+# bad
+module SomeModule
+  extend T::Sig
+  extend T::Helpers
+
+  sig { returns(String) }
+  def foo; end
+end
+
+# good
+module SomeModule
+  sig { returns(String) }
+  def foo; end
+end
+```
+
+### Configurable attributes
+
+Name | Default value | Configurable values
+--- | --- | ---
+Include | `**/*.rbi` | Array
+
 ## Sorbet/ForbidIncludeConstLiteral
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Enabled | Yes | Yes  | 0.2.0 | -
+Disabled | Yes | No | 0.2.0 | 0.5.0
 
 No documentation
 
@@ -183,15 +217,21 @@ No documentation
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Enabled | Yes | Yes  | 0.2.0 | -
+Disabled | Yes | No | 0.2.0 | 0.6.1
 
 No documentation
 
+### Configurable attributes
+
+Name | Default value | Configurable values
+--- | --- | ---
+Exclude | `db/migrate/*.rb` | Array
+
 ## Sorbet/ForbidUntypedStructProps
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Enabled | Yes | No | 0.3.8 | -
+Enabled | Yes | No | 0.4.0 | -
 
 This cop disallows use of `T.untyped` or `T.nilable(T.untyped)`
 as a prop type for `T::Struct`.
@@ -258,6 +298,30 @@ sig { params(b: String, a: Integer).void }
 def foo(b:, a: 1); end
 ```
 
+## Sorbet/OneAncestorPerLine
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.6.0 | -
+
+This cop ensures one ancestor per requires_ancestor line
+rather than chaining them as a comma-separated list.
+
+### Examples
+
+```ruby
+# bad
+module SomeModule
+  requires_ancestor Kernel, Minitest::Assertions
+end
+
+# good
+module SomeModule
+  requires_ancestor Kernel
+  requires_ancestor Minitest::Assertions
+end
+```
+
 ## Sorbet/ParametersOrderingInSignature
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -298,6 +362,32 @@ Abstract cop specific to Sorbet signatures
 
 You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
 
+## Sorbet/SingleLineRbiClassModuleDefinitions
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.6.0 | -
+
+This cop ensures empty class/module definitions in RBI files are
+done on a single line rather than being split across multiple lines.
+
+### Examples
+
+```ruby
+# bad
+module SomeModule
+end
+
+# good
+module SomeModule; end
+```
+
+### Configurable attributes
+
+Name | Default value | Configurable values
+--- | --- | ---
+Include | `**/*.rbi` | Array
+
 ## Sorbet/StrictSigil
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged

data/service.yml

@@ -3,4 +3,4 @@ owners:
   - Shopify/sorbet
 classification: library
 slack_channels:
-  - sorbet
+  - help-ruby-typing

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-05 00:00:00.000000000 Z
+date: 2021-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -85,9 +85,11 @@ files:
 - lib/rubocop-sorbet.rb
 - lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb
 - lib/rubocop/cop/sorbet/constants_from_strings.rb
+- lib/rubocop/cop/sorbet/forbid_extend_t_sig_helpers_in_shims.rb
 - lib/rubocop/cop/sorbet/forbid_include_const_literal.rb
 - lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb
 - lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb
+- lib/rubocop/cop/sorbet/one_ancestor_per_line.rb
 - lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb
 - lib/rubocop/cop/sorbet/sigils/false_sigil.rb
 - lib/rubocop/cop/sorbet/sigils/has_sigil.rb
@@ -103,6 +105,7 @@ files:
 - lib/rubocop/cop/sorbet/signatures/parameters_ordering_in_signature.rb
 - lib/rubocop/cop/sorbet/signatures/signature_build_order.rb
 - lib/rubocop/cop/sorbet/signatures/signature_cop.rb
+- lib/rubocop/cop/sorbet/single_line_rbi_class_module_definitions.rb
 - lib/rubocop/cop/sorbet_cops.rb
 - lib/rubocop/sorbet.rb
 - lib/rubocop/sorbet/inject.rb