rubocop-sorbet 0.3.7 → 0.6.0

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

@@ -0,0 +1,25 @@
+# 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'
+require_relative 'sorbet/signatures/keyword_argument_ordering'
+require_relative 'sorbet/signatures/parameters_ordering_in_signature'
+require_relative 'sorbet/signatures/signature_build_order'
+require_relative 'sorbet/signatures/enforce_signatures'
+
+require_relative 'sorbet/sigils/valid_sigil'
+require_relative 'sorbet/sigils/has_sigil'
+require_relative 'sorbet/sigils/ignore_sigil'
+require_relative 'sorbet/sigils/false_sigil'
+require_relative 'sorbet/sigils/true_sigil'
+require_relative 'sorbet/sigils/strict_sigil'
+require_relative 'sorbet/sigils/strong_sigil'
+require_relative 'sorbet/sigils/enforce_sigil_order'

data/lib/rubocop/sorbet.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require "rubocop/sorbet/version"
+require "yaml"
+
+module RuboCop
+  module Sorbet
+    class Error < StandardError; end
+
+    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end

data/lib/rubocop/sorbet/inject.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT-LICENSE.md
+module RuboCop
+  module Sorbet
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.send(:load_yaml_configuration, path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
+        puts "configuration from #{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/sorbet/version.rb

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

data/manual/cops.md

@@ -0,0 +1,32 @@
+## Available cops
+
+In the following section you find all available cops:
+
+<!-- START_COP_LIST -->
+#### Department [Sorbet](cops_sorbet.md)
+
+* [Sorbet/AllowIncompatibleOverride](cops_sorbet.md#sorbetallowincompatibleoverride)
+* [Sorbet/BindingConstantWithoutTypeAlias](cops_sorbet.md#sorbetbindingconstantwithouttypealias)
+* [Sorbet/CheckedTrueInSignature](cops_sorbet.md#sorbetcheckedtrueinsignature)
+* [Sorbet/ConstantsFromStrings](cops_sorbet.md#sorbetconstantsfromstrings)
+* [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)
+* [Sorbet/ValidSigil](cops_sorbet.md#sorbetvalidsigil)
+
+<!-- END_COP_LIST -->

data/manual/cops_sorbet.md

@@ -0,0 +1,424 @@
+# Sorbet
+
+## Sorbet/AllowIncompatibleOverride
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop disallows using `.override(allow_incompatible: true)`.
+Using `allow_incompatible` suggests a violation of the Liskov
+Substitution Principle, meaning that a subclass is not a valid
+subtype of it's superclass. This Cop prevents these design smells
+from occurring.
+
+### Examples
+
+```ruby
+# bad
+sig.override(allow_incompatible: true)
+
+# good
+sig.override
+```
+
+## Sorbet/BindingConstantWithoutTypeAlias
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2.0 | -
+
+This cop disallows binding the return value of `T.any`, `T.all`, `T.enum`
+to a constant directly. To bind the value, one must use `T.type_alias`.
+
+### Examples
+
+```ruby
+# bad
+FooOrBar = T.any(Foo, Bar)
+
+# good
+FooOrBar = T.type_alias { T.any(Foo, Bar) }
+```
+
+## Sorbet/CheckedTrueInSignature
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop disallows the usage of `checked(true)`. This usage could cause
+confusion; it could lead some people to believe that a method would be checked
+even if runtime checks have not been enabled on the class or globally.
+Additionally, in the event where checks are enabled, `checked(true)` would
+be redundant; only `checked(false)` or `soft` would change the behaviour.
+
+### Examples
+
+```ruby
+# bad
+sig { void.checked(true) }
+
+# good
+sig { void }
+```
+
+## Sorbet/ConstantsFromStrings
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop disallows the calls that are used to get constants fom Strings
+such as +constantize+, +const_get+, and +constants+.
+
+The goal of this cop is to make the code easier to statically analyze,
+more IDE-friendly, and more predictable. It leads to code that clearly
+expresses which values the constant can have.
+
+### Examples
+
+```ruby
+# bad
+class_name.constantize
+
+# bad
+constants.detect { |c| c.name == "User" }
+
+# bad
+const_get(class_name)
+
+# good
+case class_name
+when "User"
+  User
+else
+  raise ArgumentError
+end
+
+# good
+{ "User" => User }.fetch(class_name)
+```
+
+## Sorbet/EnforceSigilOrder
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.4 | -
+
+This cop checks that the Sorbet sigil comes as the first magic comment in the file.
+
+The expected order for magic comments is: typed, (en)?coding, warn_indent then frozen_string_literal.
+
+For example, the following bad ordering:
+
+```ruby
+# frozen_string_literal: true
+# typed: true
+class Foo; end
+```
+
+Will be corrected as:
+
+```ruby
+# typed: true
+# frozen_string_literal: true
+class Foo; end
+```
+
+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.
+
+## Sorbet/EnforceSignatures
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.4 | -
+
+This cop checks that every method definition and attribute accessor has a Sorbet signature.
+
+It also suggest an autocorrect with placeholders so the following code:
+
+```
+def foo(a, b, c); end
+```
+
+Will be corrected as:
+
+```
+sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped)
+def foo(a, b, c); end
+```
+
+You can configure the placeholders used by changing the following options:
+
+* `ParameterTypePlaceholder`: placeholders used for parameter types (default: 'T.untyped')
+* `ReturnTypePlaceholder`: placeholders used for return types (default: 'T.untyped')
+
+## Sorbet/FalseSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `false` sigil mandatory in all files.
+
+### Configurable attributes
+
+Name | Default value | Configurable values
+--- | --- | ---
+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
+--- | --- | --- | --- | ---
+Disabled | Yes | No | 0.2.0 | 0.5.0
+
+No documentation
+
+## Sorbet/ForbidSuperclassConstLiteral
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | 0.2.0 | 0.5.0
+
+No documentation
+
+## Sorbet/ForbidUntypedStructProps
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+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`.
+
+### Examples
+
+```ruby
+# bad
+class SomeClass
+  const :foo, T.untyped
+  prop :bar, T.nilable(T.untyped)
+end
+
+# good
+class SomeClass
+  const :foo, Integer
+  prop :bar, T.nilable(String)
+end
+```
+
+## Sorbet/HasSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet typed sigil mandatory in all files.
+
+Options:
+
+* `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false')
+* `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one
+
+If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.
+
+## Sorbet/IgnoreSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `ignore` sigil mandatory in all files.
+
+## Sorbet/KeywordArgumentOrdering
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop checks for the ordering of keyword arguments required by
+sorbet-runtime. The ordering requires that all keyword arguments
+are at the end of the parameters list, and all keyword arguments
+with a default value must be after those without default values.
+
+### Examples
+
+```ruby
+# bad
+sig { params(a: Integer, b: String).void }
+def foo(a: 1, b:); end
+
+# good
+sig { params(b: String, a: Integer).void }
+def foo(b:, a: 1); end
+```
+
+## Sorbet/OneAncestorPerLine
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | - | -
+
+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
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop checks for inconsistent ordering of parameters between the
+signature and the method definition. The sorbet-runtime gem raises
+when such inconsistency occurs.
+
+### Examples
+
+```ruby
+# bad
+sig { params(a: Integer, b: String).void }
+def foo(b:, a:); end
+
+# good
+sig { params(a: Integer, b: String).void }
+def foo(a:, b:); end
+```
+
+## Sorbet/SignatureBuildOrder
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.0 | -
+
+No documentation
+
+## Sorbet/SignatureCop
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | - | -
+
+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
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `strict` sigil mandatory in all files.
+
+## Sorbet/StrongSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `strong` sigil mandatory in all files.
+
+## Sorbet/TrueSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `true` sigil mandatory in all files.
+
+## Sorbet/ValidSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.3 | -
+
+This cop checks that every Ruby file contains a valid Sorbet sigil.
+Adapted from: https://gist.github.com/clarkdave/85aca4e16f33fd52aceb6a0a29936e52
+
+Options:
+
+* `RequireSigilOnAllFiles`: make offense if the Sorbet typed is not found in the file (default: false)
+* `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false')
+* `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one
+
+If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.