rubocop-sorbet 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8e5d981eb3753f8e4a5599105ffca85878383e8c9babe36126529d13408c578
-  data.tar.gz: 19162fbc227c9d40774bec276129f739ee885201bb688b74cd3a7901253770ac
+  metadata.gz: 680171335e42d9f614626c06b286af906fbd4a71473ad36a5133e343ca202376
+  data.tar.gz: c84b1f2a66e5f2406640d5c2543f5a936b61b25141a8136a1cdf94f36f6af2cf
 SHA512:
-  metadata.gz: fd590134345de1400d2c653b263d2b0936aa1f02f6e199fc5d2f65eca50b37aef77df4d4463afe403ca7ba3f795dd389a72164d62c796dc943fb108e4eef76df
-  data.tar.gz: 4b5caba384adc3a2b45e8532cd1dba357bf7404d577da3a24defb9279a903a7b1c02bb1efdd28571517cab33ba3fa01dde88b1319da8cd8d051ecb308cd9d8b5
+  metadata.gz: 6c93471fa6670ce5c257fa7604bf9755bd910baffcfed62348f22dcb9242868ec42c9738f2b507317340085b22ada30140e3ad618408a5563fd00d449d4a8e81
+  data.tar.gz: e105b484e8b8e75177e126e8dd3b682514a4deb4f9135ace3e97ca49d4f9dcd54dc23800676cb48386faabe7a779deca53335f01affdc981351d11647cbed47c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorbet (0.3.3)
+    rubocop-sorbet (0.3.4)
 
 GEM
   remote: https://rubygems.org/

data/config/default.yml

@@ -1,3 +1,6 @@
 Sorbet/ValidSigil:
   Enabled: true
   EnforcedStyle: typed_files
+
+Sorbet/EnforceSignatures:
+  Enabled: true

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

@@ -14,13 +14,22 @@ module RuboCop
       #   FooOrBar = T.any(Foo, Bar)
       #
       #   # good
-      #   FooOrBar = T.type_alias(T.any(Foo, Bar))
+      #   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?])
         PATTERN
 
         def_node_matcher(:using_type_alias?, <<-PATTERN)
+          (block
+            (send
+              (const nil? :T) :type_alias)
+              _
+              _
+          )
+        PATTERN
+
+        def_node_matcher(:using_deprecated_type_alias_syntax?, <<-PATTERN)
           (
             send
             (const nil? :T)
@@ -58,6 +67,16 @@ module RuboCop
 
         def on_casgn(node)
           return unless binding_unaliased_type?(node) && !using_type_alias?(node.children[2])
+          if using_deprecated_type_alias_syntax?(node.children[2])
+            add_offense(
+              node.children[2],
+              message: "It looks like you're using the old `T.type_alias` syntax. " \
+              '`T.type_alias` now expects a block.' \
+              'Run Sorbet with the options "--autocorrect --error-white-list=5043" ' \
+              'to automatically upgrade to the new syntax.'
+            )
+            return
+          end
           add_offense(
             node.children[2],
             message: "It looks like you're trying to bind a type to a constant. " \
@@ -69,7 +88,7 @@ module RuboCop
           lambda do |corrector|
             corrector.replace(
               node.source_range,
-              "T.type_alias(#{node.source})"
+              "T.type_alias { #{node.source} }"
             )
           end
         end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # 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.
+      class EnforceSigilOrder < ValidSigil
+        def investigate(processed_source)
+          return if processed_source.tokens.empty?
+
+          tokens = extract_magic_comments(processed_source)
+          return if tokens.empty?
+
+          check_magic_comments_order(tokens)
+        end
+
+        def autocorrect(_node)
+          lambda do |corrector|
+            tokens = extract_magic_comments(processed_source)
+
+            # Get the magic comments tokens in their expected order
+            expected = PREFERRED_ORDER.keys.map do |re|
+              tokens.select { |token| re.match?(token.text) }
+            end.flatten
+
+            tokens.each_with_index do |token, index|
+              corrector.replace(token.pos, expected[index].text)
+            end
+          end
+        end
+
+        protected
+
+        CODING_REGEX = /#\s+(en)?coding:(?:\s+([\w]+))?/
+        INDENT_REGEX = /#\s+warn_indent:(?:\s+([\w]+))?/
+        FROZEN_REGEX = /#\s+frozen_string_literal:(?:\s+([\w]+))?/
+
+        PREFERRED_ORDER = {
+          SIGIL_REGEX => 'typed',
+          CODING_REGEX => 'encoding',
+          INDENT_REGEX => 'warn_indent',
+          FROZEN_REGEX => 'frozen_string_literal',
+        }.freeze
+
+        MAGIC_REGEX = Regexp.union(*PREFERRED_ORDER.keys)
+
+        # extraction
+
+        # Get all the tokens in `processed_source` that match `MAGIC_REGEX`
+        def extract_magic_comments(processed_source)
+          processed_source.tokens
+            .take_while { |token| token.type == :tCOMMENT }
+            .select { |token| MAGIC_REGEX.match?(token.text) }
+        end
+
+        # checks
+
+        def check_magic_comments_order(tokens)
+          # Get the current magic comments order
+          order = tokens.map do |token|
+            PREFERRED_ORDER.keys.find { |re| re.match?(token.text) }
+          end.compact.uniq
+
+          # Get the expected magic comments order based on the one used in the actual source
+          expected = PREFERRED_ORDER.keys.select do |re|
+            tokens.any? { |token| re.match?(token.text) }
+          end.uniq
+
+          if order != expected
+            tokens.each do |token|
+              add_offense(
+                token,
+                location: token.pos,
+                message: "Magic comments should be in the following order: #{PREFERRED_ORDER.values.join(', ')}."
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+require_relative 'signature_cop'
 
 module RuboCop
   module Cop
@@ -18,13 +19,9 @@ module RuboCop
       #
       #   # good
       #   sig { void }
-      class CheckedTrueInSignature < RuboCop::Cop::Cop
+      class CheckedTrueInSignature < SignatureCop
         include(RuboCop::Cop::RangeHelp)
 
-        def_node_matcher(:signature?, <<~PATTERN)
-          (block (send nil? :sig) (args) ...)
-        PATTERN
-
         def_node_search(:offending_node, <<~PATTERN)
           (send _ :checked (true))
         PATTERN
@@ -36,9 +33,7 @@ module RuboCop
             '`include(WaffleCone::RuntimeChecks)` to this module and set other methods to `checked(false)`.'
         private_constant(:MESSAGE)
 
-        def on_block(node)
-          return unless signature?(node)
-
+        def on_signature(node)
           error = offending_node(node).first
           return unless error
 

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'stringio'
+require_relative 'signature_cop'
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # 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')
+      class EnforceSignatures < SignatureCop
+        def_node_matcher(:accessor?, <<-PATTERN)
+          (send nil? {:attr_reader :attr_writer :attr_accessor} ...)
+        PATTERN
+
+        def on_def(node)
+          check_node(node)
+        end
+
+        def on_defs(node)
+          check_node(node)
+        end
+
+        def on_send(node)
+          return unless accessor?(node)
+          check_node(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            suggest = SigSuggestion.new(node.loc.column, param_type_placeholder, return_type_placeholder)
+
+            if node.is_a?(RuboCop::AST::DefNode) # def something
+              node.arguments.each do |arg|
+                suggest.params << arg.children.first
+              end
+            elsif accessor?(node) # attr reader, writer, accessor
+              method = node.children[1]
+              symbol = node.children[2]
+              suggest.params << symbol.value if symbol && (method == :attr_writer || method == :attr_accessor)
+              suggest.returns = 'void' if method == :attr_writer
+            end
+
+            corrector.insert_before(node.loc.expression, suggest.to_autocorrect)
+          end
+        end
+
+        private
+
+        def check_node(node)
+          prev = previous_node(node)
+          unless signature?(prev)
+            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]
+        end
+
+        def param_type_placeholder
+          cop_config['ParameterTypePlaceholder'] || 'T.untyped'
+        end
+
+        def return_type_placeholder
+          cop_config['ReturnTypePlaceholder'] || 'T.untyped'
+        end
+
+        class SigSuggestion
+          attr_accessor :params, :returns
+
+          def initialize(indent, param_placeholder, return_placeholder)
+            @params = []
+            @returns = nil
+            @indent = indent
+            @param_placeholder = param_placeholder
+            @return_placeholder = return_placeholder
+          end
+
+          def to_autocorrect
+            out = StringIO.new
+            out << 'sig { '
+            out << generate_params
+            out << generate_return
+            out << " }\n"
+            out << ' ' * @indent # preserve indent for the next line
+            out.string
+          end
+
+          private
+
+          def generate_params
+            return if @params.empty?
+            out = StringIO.new
+            out << 'params('
+            out << @params.map do |param|
+              "#{param}: #{@param_placeholder}"
+            end.join(", ")
+            out << ').'
+            out.string
+          end
+
+          def generate_return
+            return "returns(#{@return_placeholder})" if @returns.nil?
+            return @returns if @returns == 'void'
+            "returns(#{@returns})"
+          end
+        end
+      end
+    end
+  end
+end

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,18 +19,12 @@ 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?

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,7 +12,7 @@ end
 module RuboCop
   module Cop
     module Sorbet
-      class SignatureBuildOrder < RuboCop::Cop::Cop
+      class SignatureBuildOrder < SignatureCop
         ORDER =
           [
             :type_parameters,
@@ -27,17 +28,11 @@ module RuboCop
             :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_sorbet.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'rubocop/cop/sorbet/allow_incompatible_override'
 require_relative 'rubocop/cop/sorbet/binding_constants_without_type_alias'
-require_relative 'rubocop/cop/sorbet/checked_true_in_signature'
 require_relative 'rubocop/cop/sorbet/constants_from_strings'
-require_relative 'rubocop/cop/sorbet/signature_build_order'
 require_relative 'rubocop/cop/sorbet/forbid_superclass_const_literal'
 require_relative 'rubocop/cop/sorbet/forbid_include_const_literal'
-require_relative 'rubocop/cop/sorbet/parameters_ordering_in_signature'
-require_relative 'rubocop/cop/sorbet/keyword_argument_ordering'
+
+require_relative 'rubocop/cop/sorbet/signatures/allow_incompatible_override'
+require_relative 'rubocop/cop/sorbet/signatures/checked_true_in_signature'
+require_relative 'rubocop/cop/sorbet/signatures/keyword_argument_ordering'
+require_relative 'rubocop/cop/sorbet/signatures/parameters_ordering_in_signature'
+require_relative 'rubocop/cop/sorbet/signatures/signature_build_order'
+require_relative 'rubocop/cop/sorbet/signatures/enforce_signatures'
 
 require_relative 'rubocop/cop/sorbet/sigils/valid_sigil'
 require_relative 'rubocop/cop/sorbet/sigils/has_sigil'
@@ -17,3 +19,4 @@ require_relative 'rubocop/cop/sorbet/sigils/false_sigil'
 require_relative 'rubocop/cop/sorbet/sigils/true_sigil'
 require_relative 'rubocop/cop/sorbet/sigils/strict_sigil'
 require_relative 'rubocop/cop/sorbet/sigils/strong_sigil'
+require_relative 'rubocop/cop/sorbet/sigils/enforce_sigil_order'

data/rubocop-sorbet.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'rubocop-sorbet'
-  spec.version       = '0.3.3'
+  spec.version       = '0.3.4'
   spec.authors       = ['Ufuk Kayserilioglu', 'Alan Wu', 'Alexandre Terrasa', 'Peter Zhu']
   spec.email         = ['ruby@shopify.com']
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-08 00:00:00.000000000 Z
+date: 2019-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -80,14 +80,11 @@ files:
 - config/default.yml
 - dev.yml
 - lib/rubocop-sorbet.rb
-- lib/rubocop/cop/sorbet/allow_incompatible_override.rb
 - lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb
-- lib/rubocop/cop/sorbet/checked_true_in_signature.rb
 - lib/rubocop/cop/sorbet/constants_from_strings.rb
 - lib/rubocop/cop/sorbet/forbid_include_const_literal.rb
 - lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb
-- lib/rubocop/cop/sorbet/keyword_argument_ordering.rb
-- lib/rubocop/cop/sorbet/parameters_ordering_in_signature.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
 - lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb
@@ -95,7 +92,13 @@ files:
 - lib/rubocop/cop/sorbet/sigils/strong_sigil.rb
 - lib/rubocop/cop/sorbet/sigils/true_sigil.rb
 - lib/rubocop/cop/sorbet/sigils/valid_sigil.rb
-- lib/rubocop/cop/sorbet/signature_build_order.rb
+- lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb
+- lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb
+- lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb
+- lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb
+- 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_sorbet.rb
 - rubocop-sorbet.gemspec
 - service.yml