rubocop-sorbet 0.3.3 → 0.4.0

data/lib/rubocop/cop/sorbet/{keyword_argument_ordering.rb → signatures/keyword_argument_ordering.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require_relative 'signature_cop'
 
 module RuboCop
   module Cop
@@ -19,14 +20,8 @@ module RuboCop
       #   # good
       #   sig { params(b: String, a: Integer).void }
       #   def foo(b:, a: 1); end
-      class KeywordArgumentOrdering < RuboCop::Cop::Cop
-        def_node_matcher(:signature?, <<-PATTERN)
-          (block (send nil? :sig) (args) ...)
-        PATTERN
-
-        def on_block(node)
-          return unless signature?(node)
-
+      class KeywordArgumentOrdering < SignatureCop
+        def on_signature(node)
           method_node = node.parent.children[node.sibling_index + 1]
           return if method_node.nil?
           method_parameters = method_node.arguments
@@ -40,7 +35,7 @@ module RuboCop
           out_of_kwoptarg = false
 
           parameters.reverse.each do |param|
-            out_of_kwoptarg = true unless param.type == :kwoptarg || param.type == :blockarg
+            out_of_kwoptarg = true unless param.type == :kwoptarg || param.type == :blockarg || param.type == :kwrestarg
 
             next unless param.type == :kwoptarg && out_of_kwoptarg
 

data/lib/rubocop/cop/sorbet/{parameters_ordering_in_signature.rb → signatures/parameters_ordering_in_signature.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require_relative 'signature_cop'
 
 module RuboCop
   module Cop
@@ -18,26 +19,16 @@ module RuboCop
       #   # good
       #   sig { params(a: Integer, b: String).void }
       #   def foo(a:, b:); end
-      class ParametersOrderingInSignature < RuboCop::Cop::Cop
-        def_node_matcher(:signature?, <<-PATTERN)
-          (block (send nil? :sig) (args) ...)
-        PATTERN
-
+      class ParametersOrderingInSignature < SignatureCop
         def_node_search(:signature_params, <<-PATTERN)
           (send _ :params ...)
         PATTERN
 
-        def on_block(node)
-          return unless signature?(node)
-
+        def on_signature(node)
           sig_params = signature_params(node).first
-          sig_params_order =
-            if sig_params.nil?
-              []
-            else
-              sig_params.arguments.first.keys.map(&:value)
-            end
 
+          sig_params_order = extract_parameters(sig_params)
+          return if sig_params_order.nil?
           method_node = node.parent.children[node.sibling_index + 1]
           return if method_node.nil? || method_node.type != :def
           method_parameters = method_node.arguments
@@ -47,6 +38,18 @@ module RuboCop
 
         private
 
+        def extract_parameters(sig_params)
+          return [] if sig_params.nil?
+
+          arguments = sig_params.arguments.first
+          return arguments.keys.map(&:value) if RuboCop::AST::HashNode === arguments
+
+          add_offense(
+            sig_params,
+            message: "Invalid signature."
+          )
+        end
+
         def check_for_inconsistent_param_ordering(sig_params_order, parameters)
           parameters.each_with_index do |param, index|
             param_name = param.children[0]

data/lib/rubocop/cop/sorbet/{signature_build_order.rb → signatures/signature_build_order.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require_relative 'signature_cop'
 
 begin
   require 'unparser'
@@ -11,33 +12,26 @@ end
 module RuboCop
   module Cop
     module Sorbet
-      class SignatureBuildOrder < RuboCop::Cop::Cop
+      class SignatureBuildOrder < SignatureCop
         ORDER =
           [
+            :abstract,
+            :override,
+            :overridable,
             :type_parameters,
             :params,
             :returns,
             :void,
-            :abstract,
-            :implementation,
-            :override,
-            :overridable,
             :soft,
             :checked,
             :on_failure,
           ].each_with_index.to_h.freeze
 
-        def_node_matcher(:signature?, <<~PATTERN)
-          (block (send nil? :sig) (args) ...)
-        PATTERN
-
         def_node_search(:root_call, <<~PATTERN)
           (send nil? {#{ORDER.keys.map(&:inspect).join(' ')}} ...)
         PATTERN
 
-        def on_block(node)
-          return unless signature?(node)
-
+        def on_signature(node)
           calls = call_chain(node.children[2]).map(&:method_name)
           return unless calls.any?
 

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Abstract cop specific to Sorbet signatures
+      #
+      # You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
+      class SignatureCop < RuboCop::Cop::Cop
+        @registry = Cop.registry # So we can properly subclass this cop
+
+        def_node_matcher(:signature?, <<~PATTERN)
+          (block (send nil? :sig) (args) ...)
+        PATTERN
+
+        def on_block(node)
+          on_signature(node) if signature?(node)
+        end
+
+        def on_signature(_)
+          # To be defined in subclasses
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet_cops.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative 'sorbet/binding_constants_without_type_alias'
+require_relative 'sorbet/constants_from_strings'
+require_relative 'sorbet/forbid_superclass_const_literal'
+require_relative 'sorbet/forbid_include_const_literal'
+require_relative 'sorbet/forbid_untyped_struct_props'
+
+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.4.0"
+  end
+end

data/manual/cops.md

@@ -0,0 +1,29 @@
+## 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/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/ParametersOrderingInSignature](cops_sorbet.md#sorbetparametersorderinginsignature)
+* [Sorbet/SignatureBuildOrder](cops_sorbet.md#sorbetsignaturebuildorder)
+* [Sorbet/SignatureCop](cops_sorbet.md#sorbetsignaturecop)
+* [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,340 @@
+# 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/ForbidIncludeConstLiteral
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2.0 | -
+
+No documentation
+
+## Sorbet/ForbidSuperclassConstLiteral
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2.0 | -
+
+No documentation
+
+## Sorbet/ForbidUntypedStructProps
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.3.8 | -
+
+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/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/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.