rubocop 1.18.4 → 1.19.0

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

@@ -143,13 +143,6 @@ module RuboCop
           indent_level(base_line)
         end
 
-        def indent_level(str)
-          indentations = str.lines
-                            .map { |line| line[/^\s*/] }
-                            .reject { |line| line.end_with?("\n") }
-          indentations.empty? ? 0 : indentations.min_by(&:size).size
-        end
-
         # Returns '~', '-' or nil
         def heredoc_indent_type(node)
           node.source[/^<<([~-])/, 1]

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

@@ -57,7 +57,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
+            next unless /\A#+[^#\s=+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)

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

@@ -11,8 +11,7 @@ module RuboCop
       # concatenated string parts shall be indented regardless of `EnforcedStyle` configuration.
       #
       # If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step
-      # more than the first line. Lines 3 and forward shall be aligned with line 2. Here too there
-      # are exceptions. Values in a hash literal are always aligned.
+      # more than the first line. Lines 3 and forward shall be aligned with line 2.
       #
       # @example
       #   # bad
@@ -34,29 +33,44 @@ module RuboCop
       #       'z'
       #   end
       #
-      #   my_hash = {
-      #     first: 'a message' \
-      #            'in two parts'
-      #   }
-      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   puts 'x' \
       #     'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
       #   # good
       #   puts 'x' \
       #        'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
       # @example EnforcedStyle: indented
       #   # bad
       #   result = 'x' \
       #            'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
       #   # good
       #   result = 'x' \
       #     'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
       class LineEndStringConcatenationIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
@@ -70,7 +84,7 @@ module RuboCop
           return unless strings_concatenated_with_backslash?(node)
 
           children = node.children
-          if style == :aligned && !always_indented?(node) || always_aligned?(node)
+          if style == :aligned && !always_indented?(node)
             check_aligned(children, 1)
           else
             check_indented(children)
@@ -94,10 +108,6 @@ module RuboCop
           PARENT_TYPES_FOR_INDENTED.include?(dstr_node.parent&.type)
         end
 
-        def always_aligned?(dstr_node)
-          dstr_node.parent&.pair_type?
-        end
-
         def check_aligned(children, start_index)
           base_column = children[start_index - 1].loc.column
           children[start_index..-1].each do |child|
@@ -108,11 +118,20 @@ module RuboCop
         end
 
         def check_indented(children)
-          base_column = children[0].source_range.source_line =~ /\S/
-          @column_delta = base_column + configured_indentation_width - children[1].loc.column
+          @column_delta = base_column(children[0]) + configured_indentation_width -
+                          children[1].loc.column
           add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
         end
 
+        def base_column(child)
+          grandparent = child.parent.parent
+          if grandparent&.type == :pair
+            grandparent.loc.column
+          else
+            child.source_range.source_line =~ /\S/
+          end
+        end
+
         def add_offense_and_correction(node, message)
           add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end

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,25 @@ 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.selector
+
+          if send_node_loc.respond_to?(:dot) && (dot = send_node_loc.dot) &&
+             aligned_with_leading_dot?(do_keyword_line, dot, rescue_keyword_column)
+            return true
+          end
+
+          do_keyword_line == selector.line && rescue_keyword_column == selector.column
+        end
 
-          node.each_ancestor(*ancestor_types).first
+        def aligned_with_leading_dot?(do_keyword_line, dot, rescue_keyword_column)
+          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/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