rubocop 1.18.3 → 1.20.0

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -6,6 +6,9 @@ module RuboCop
       # This cop ensures that each argument in a multi-line method call
       # starts on a separate line.
       #
+      # NOTE: this cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
+      #
       # @example
       #
       #   # bad

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -29,8 +29,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
-        RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
+        ANCESTOR_TYPES = %i[kwbegin def defs class module block].freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
@@ -118,6 +117,8 @@ module RuboCop
           ancestor_node = ancestor_node(node)
 
           return ancestor_node if ancestor_node.nil? || ancestor_node.kwbegin_type?
+          return if ancestor_node.respond_to?(:send_node) &&
+                    aligned_with_line_break_method?(ancestor_node, node)
 
           assignment_node = assignment_node(ancestor_node)
           return assignment_node if same_line?(ancestor_node, assignment_node)
@@ -129,14 +130,26 @@ module RuboCop
         end
 
         def ancestor_node(node)
-          ancestor_types =
-            if target_ruby_version >= 2.5
-              RUBY_2_5_ANCESTOR_TYPES
-            else
-              ANCESTOR_TYPES
-            end
+          node.each_ancestor(*ANCESTOR_TYPES).first
+        end
+
+        def aligned_with_line_break_method?(ancestor_node, node)
+          send_node_loc = ancestor_node.send_node.loc
+          do_keyword_line = ancestor_node.loc.begin.line
+          rescue_keyword_column = node.loc.keyword.column
+          selector = send_node_loc.respond_to?(:selector) ? send_node_loc.selector : send_node_loc
+
+          if aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)
+            return true
+          end
+
+          do_keyword_line == selector.line && rescue_keyword_column == selector.column
+        end
+
+        def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)
+          return false unless send_node_loc.respond_to?(:dot) && (dot = send_node_loc.dot)
 
-          node.each_ancestor(*ancestor_types).first
+          do_keyword_line == dot.line && rescue_keyword_column == dot.column
         end
 
         def assignment_node(node)

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -108,6 +108,14 @@ module RuboCop
           check_operator(:assignment, node.loc.operator, rhs.source_range)
         end
 
+        def on_casgn(node)
+          _, _, right, = *node
+
+          return unless right
+
+          check_operator(:assignment, node.loc.operator, right.source_range)
+        end
+
         def on_binary(node)
           _, rhs, = *node
 
@@ -134,7 +142,6 @@ module RuboCop
         alias on_and      on_binary
         alias on_lvasgn   on_assignment
         alias on_masgn    on_assignment
-        alias on_casgn    on_special_asgn
         alias on_ivasgn   on_assignment
         alias on_cvasgn   on_assignment
         alias on_gvasgn   on_assignment

data/lib/rubocop/cop/layout/space_before_comment.rb

@@ -18,7 +18,7 @@ module RuboCop
         MSG = 'Put a space before an end-of-line comment.'
 
         def on_new_investigation
-          processed_source.tokens.each_cons(2) do |token1, token2|
+          processed_source.sorted_tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
             next unless token1.line == token2.line
             next unless token1.pos.end == token2.pos.begin

data/lib/rubocop/cop/layout/space_inside_parens.rb

@@ -43,12 +43,12 @@ module RuboCop
         MSG_SPACE = 'No space inside parentheses detected.'
 
         def on_new_investigation
-          @processed_source = processed_source
+          tokens = processed_source.sorted_tokens
 
           if style == :space
-            process_with_space_style(processed_source)
+            process_with_space_style(tokens)
           else
-            each_extraneous_space(processed_source.tokens) do |range|
+            each_extraneous_space(tokens) do |range|
               add_offense(range) do |corrector|
                 corrector.remove(range)
               end
@@ -58,8 +58,8 @@ module RuboCop
 
         private
 
-        def process_with_space_style(processed_source)
-          processed_source.tokens.each_cons(2) do |token1, token2|
+        def process_with_space_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
             each_extraneous_space_in_empty_parens(token1, token2) do |range|
               add_offense(range) do |corrector|
                 corrector.remove(range)

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -41,6 +41,7 @@ module RuboCop
       #
       class TrailingWhitespace < Base
         include RangeHelp
+        include Heredoc
         extend AutoCorrector
 
         MSG = 'Trailing whitespace detected.'
@@ -54,6 +55,8 @@ module RuboCop
           end
         end
 
+        def on_heredoc(_node); end
+
         private
 
         def process_line(line, lineno)
@@ -63,13 +66,33 @@ module RuboCop
           range = offense_range(lineno, line)
           add_offense(range) do |corrector|
             if heredoc
-              corrector.wrap(range, "\#{'", "'}") unless static?(heredoc)
+              process_line_in_heredoc(corrector, range, heredoc)
             else
               corrector.remove(range)
             end
           end
         end
 
+        def process_line_in_heredoc(corrector, range, heredoc)
+          indent_level = indent_level(find_heredoc(range.line).loc.heredoc_body.source)
+          whitespace_only = whitespace_only?(range)
+          if whitespace_only && whitespace_is_indentation?(range, indent_level)
+            corrector.remove(range)
+          elsif !static?(heredoc)
+            range = range_between(range.begin_pos + indent_level, range.end_pos) if whitespace_only
+            corrector.wrap(range, "\#{'", "'}")
+          end
+        end
+
+        def whitespace_is_indentation?(range, level)
+          range.source[/ +/].length <= level
+        end
+
+        def whitespace_only?(range)
+          source = range_with_surrounding_space(range: range).source
+          source.start_with?("\n") && source.end_with?("\n")
+        end
+
         def static?(heredoc)
           heredoc.loc.expression.source.end_with? "'"
         end

data/lib/rubocop/cop/lint/ambiguous_range.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous ranges.
+      #
+      # Ranges have quite low precedence, which leads to unexpected behaviour when
+      # using a range with other operators. This cop avoids that by making ranges
+      # explicit by requiring parenthesis around complex range boundaries (anything
+      # that is not a basic literal: numerics, strings, symbols, etc.).
+      #
+      # NOTE: The cop auto-corrects by wrapping the entire boundary in parentheses, which
+      # makes the outcome more explicit but is possible to not be the intention of the
+      # programmer. For this reason, this cop's auto-correct is marked as unsafe (it
+      # will not change the behaviour of the code, but will not necessarily match the
+      # intent of the program).
+      #
+      # This cop can be configured with `RequireParenthesesForMethodChains` in order to
+      # specify whether method chains (including `self.foo`) should be wrapped in parens
+      # by this cop.
+      #
+      # NOTE: Regardless of this configuration, if a method receiver is a basic literal
+      # value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`.
+      #
+      # @example
+      #   # bad
+      #   x || 1..2
+      #   (x || 1..2)
+      #   1..2.to_a
+      #
+      #   # good, unambiguous
+      #   1..2
+      #   'a'..'z'
+      #   :bar..:baz
+      #   MyClass::MIN..MyClass::MAX
+      #   @min..@max
+      #   a..b
+      #   -a..b
+      #
+      #   # good, ambiguity removed
+      #   x || (1..2)
+      #   (x || 1)..2
+      #   (x || 1)..(y || 2)
+      #   (1..2).to_a
+      #
+      # @example RequireParenthesesForMethodChains: false (default)
+      #   # good
+      #   a.foo..b.bar
+      #   (a.foo)..(b.bar)
+      #
+      # @example RequireParenthesesForMethodChains: true
+      #   # bad
+      #   a.foo..b.bar
+      #
+      #   # good
+      #   (a.foo)..(b.bar)
+      #
+      class AmbiguousRange < Base
+        extend AutoCorrector
+
+        MSG = 'Wrap complex range boundaries with parentheses to avoid ambiguity.'
+
+        def on_irange(node)
+          each_boundary(node) do |boundary|
+            next if acceptable?(boundary)
+
+            add_offense(boundary) do |corrector|
+              corrector.wrap(boundary, '(', ')')
+            end
+          end
+        end
+        alias on_erange on_irange
+
+        private
+
+        def each_boundary(range)
+          yield range.begin if range.begin
+          yield range.end if range.end
+        end
+
+        def acceptable?(node)
+          node.begin_type? ||
+            node.basic_literal? ||
+            node.variable? || node.const_type? ||
+            node.call_type? && acceptable_call?(node)
+        end
+
+        def acceptable_call?(node)
+          return true if node.unary_operation?
+
+          # Require parentheses when making a method call on a literal
+          # to avoid the ambiguity of `1..2.to_a`.
+          return false if node.receiver&.basic_literal?
+
+          require_parentheses_for_method_chain? || node.receiver.nil?
+        end
+
+        def require_parentheses_for_method_chain?
+          !cop_config['RequireParenthesesForMethodChains']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -46,12 +46,11 @@ module RuboCop
           node = processed_source.ast.each_node(:regexp).find do |regexp_node|
             regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
           end
-
           find_offense_node(node.parent, node)
         end
 
         def find_offense_node(node, regexp_receiver)
-          return node unless node.parent
+          return node if first_argument_is_regexp?(node) || !node.parent
 
           if (node.parent.send_type? && node.receiver) ||
              method_chain_to_regexp_receiver?(node, regexp_receiver)
@@ -61,6 +60,10 @@ module RuboCop
           node
         end
 
+        def first_argument_is_regexp?(node)
+          node.send_type? && node.first_argument&.regexp_type?
+        end
+
         def method_chain_to_regexp_receiver?(node, regexp_receiver)
           return false unless (parent = node.parent)
           return false unless (parent_receiver = parent.receiver)

data/lib/rubocop/cop/lint/debugger.rb

@@ -7,8 +7,8 @@ module RuboCop
       # not be kept for production code.
       #
       # The cop can be configured using `DebuggerMethods`. By default, a number of gems
-      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `Pry`, `Rails`,
-      # and `WebConsole`). Additional methods can be added.
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`,
+      # `Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added.
       #
       # Specific default groups can be disabled if necessary:
       #

data/lib/rubocop/cop/lint/duplicate_branch.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks that there are no repeated bodies
-      # within `if/unless`, `case-when` and `rescue` constructs.
+      # within `if/unless`, `case-when`, `case-in` and `rescue` constructs.
       #
       # With `IgnoreLiteralBranches: true`, branches are not registered
       # as offenses if they return a basic literal value (string, symbol,
@@ -97,6 +97,7 @@ module RuboCop
         end
         alias on_if on_branching_statement
         alias on_case on_branching_statement
+        alias on_case_match on_branching_statement
         alias on_rescue on_branching_statement
 
         private

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -135,11 +135,14 @@ module RuboCop
         def found_instance_method(node, name)
           return unless (scope = node.parent_module_name)
 
-          if scope =~ /\A#<Class:(.*)>\Z/
-            found_method(node, "#{Regexp.last_match(1)}.#{name}")
-          else
-            found_method(node, "#{scope}##{name}")
-          end
+          # Humanize the scope
+          scope = scope.sub(
+            /(?:(?<name>.*)::)#<Class:\k<name>>|#<Class:(?<name>.*)>(?:::)?/,
+            '\k<name>.'
+          )
+          scope << '#' unless scope.end_with?('.')
+
+          found_method(node, "#{scope}#{name}")
         end
 
         def found_method(node, method_name)

data/lib/rubocop/cop/lint/shadowed_argument.rb

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def reference_pos(node)
-          node = node.parent.masgn_type? ? node.parent : node
+          node = node.parent if node.parent.masgn_type?
 
           node.source_range.begin_pos
         end

data/lib/rubocop/cop/mixin/annotation_comment.rb

@@ -2,40 +2,63 @@
 
 module RuboCop
   module Cop
-    module Style
-      # Common functionality related to annotation comments.
-      module AnnotationComment
-        private
-
-        # @api public
-        def annotation?(comment)
-          _margin, first_word, colon, space, note = split_comment(comment)
-          keyword_appearance?(first_word, colon, space) &&
-            !just_first_word_of_sentence?(first_word, colon, space, note)
-        end
-
-        # @api public
-        def split_comment(comment)
-          match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
-          return false unless match
-
-          match.captures
-        end
-
-        # @api public
-        def keyword_appearance?(first_word, colon, space)
-          first_word && keyword?(first_word.upcase) && (colon || space)
-        end
-
-        # @api private
-        def just_first_word_of_sentence?(first_word, colon, space, note)
-          first_word == first_word.capitalize && !colon && space && note
-        end
-
-        # @api public
-        def keyword?(word)
-          config.for_cop('Style/CommentAnnotation')['Keywords'].include?(word)
-        end
+    # Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`).
+    class AnnotationComment
+      extend Forwardable
+
+      attr_reader :comment, :margin, :keyword, :colon, :space, :note
+
+      # @param [Parser::Source::Comment] comment
+      # @param [Array<String>] keywords
+      def initialize(comment, keywords)
+        @comment = comment
+        @keywords = keywords
+        @margin, @keyword, @colon, @space, @note = split_comment(comment)
+      end
+
+      def annotation?
+        keyword_appearance? && !just_keyword_of_sentence?
+      end
+
+      def correct?(colon:)
+        return false unless keyword && space && note
+        return false unless keyword == keyword.upcase
+
+        self.colon.nil? == !colon
+      end
+
+      # Returns the range bounds for just the annotation
+      def bounds
+        start = comment.loc.expression.begin_pos + margin.length
+        length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
+        [start, start + length]
+      end
+
+      private
+
+      attr_reader :keywords
+
+      def split_comment(comment)
+        # Sort keywords by reverse length so that if a keyword is in a phrase
+        # but also on its own, both will match properly.
+        keywords_regex = Regexp.new(
+          Regexp.union(keywords.sort_by { |w| -w.length }).source,
+          Regexp::IGNORECASE
+        )
+        regex = /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+
+        match = comment.text.match(regex)
+        return false unless match
+
+        match.captures
+      end
+
+      def keyword_appearance?
+        keyword && (colon || space)
+      end
+
+      def just_keyword_of_sentence?
+        keyword == keyword.capitalize && !colon && space && note
       end
     end
   end