rubocop 0.52.1 → 0.53.0

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

@@ -25,7 +25,7 @@ module RuboCop
       #     x
       #   end
       class UselessSetterCall < Cop
-        MSG = 'Useless setter call to local variable `%s`.'.freeze
+        MSG = 'Useless setter call to local variable `%<variable>s`.'.freeze
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
         def on_def(node)
@@ -42,7 +42,7 @@ module RuboCop
           add_offense(
             receiver,
             location: :name,
-            message: format(MSG, receiver.loc.name.source)
+            message: format(MSG, variable: receiver.loc.name.source)
           )
         end
         alias on_defs on_def

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for operators, variables and literals used
-      # in void context.
+      # This cop checks for operators, variables, literals, and nonmutating
+      # methods used in void context.
       #
       # @example
       #
@@ -26,6 +26,15 @@ module RuboCop
       #
       # @example
       #
+      #   # bad, when CheckForMethodsWithNoSideEffects is set true
+      #
+      #   def some_method(some_array)
+      #     some_array.sort
+      #     do_something(some_array)
+      #   end
+      #
+      # @example
+      #
       #   # good
       #
       #   def some_method
@@ -41,17 +50,34 @@ module RuboCop
       #     do_something
       #     some_var
       #   end
+      #
+      # @example
+      #
+      #   # good, when CheckForMethodsWithNoSideEffects is set true
+      #
+      #   def some_method(some_array)
+      #     some_array.sort!
+      #     do_something(some_array)
+      #   end
       class Void < Cop
-        OP_MSG = 'Operator `%s` used in void context.'.freeze
-        VAR_MSG = 'Variable `%s` used in void context.'.freeze
-        LIT_MSG = 'Literal `%s` used in void context.'.freeze
+        OP_MSG = 'Operator `%<op>s` used in void context.'.freeze
+        VAR_MSG = 'Variable `%<var>s` used in void context.'.freeze
+        LIT_MSG = 'Literal `%<lit>s` used in void context.'.freeze
         SELF_MSG = '`self` used in void context.'.freeze
-        DEFINED_MSG = '`%s` used in void context.'.freeze
+        DEFINED_MSG = '`%<defined>s` used in void context.'.freeze
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. ' \
+          'Did you mean `#%<method>s!`?'.freeze
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
         OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
         VOID_CONTEXT_TYPES = %i[def for block].freeze
+        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact downcase
+                                 encode flatten gsub lstrip map next reject
+                                 reverse rotate rstrip scrub select shuffle
+                                 slice sort sort_by squeeze strip sub succ
+                                 swapcase tr tr_s transform_values
+                                 unicode_normalize uniq upcase].freeze
 
         def on_begin(node)
           check_begin(node)
@@ -69,6 +95,9 @@ module RuboCop
             check_var(expr)
             check_self(expr)
             check_defined(expr)
+            if cop_config['CheckForMethodsWithNoSideEffects']
+              check_nonmutating(expr)
+            end
           end
         end
 
@@ -77,7 +106,7 @@ module RuboCop
 
           add_offense(node,
                       location: :selector,
-                      message: format(OP_MSG, node.method_name))
+                      message: format(OP_MSG, op: node.method_name))
         end
 
         def check_var(node)
@@ -85,13 +114,13 @@ module RuboCop
 
           add_offense(node,
                       location: :name,
-                      message: format(VAR_MSG, node.loc.name.source))
+                      message: format(VAR_MSG, var: node.loc.name.source))
         end
 
         def check_literal(node)
           return if !node.literal? || node.xstr_type?
 
-          add_offense(node, message: format(LIT_MSG, node.source))
+          add_offense(node, message: format(LIT_MSG, lit: node.source))
         end
 
         def check_self(node)
@@ -103,7 +132,17 @@ module RuboCop
         def check_defined(node)
           return unless node.defined_type?
 
-          add_offense(node, message: format(DEFINED_MSG, node.source))
+          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
+        end
+
+        def check_nonmutating(node)
+          unless node.send_type? &&
+                 NONMUTATING_METHODS.include?(node.method_name)
+            return
+          end
+
+          add_offense(node, message: format(NONMUTATING_MSG,
+                                            method: node.method_name))
         end
 
         def in_void_context?(node)

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -20,7 +20,7 @@ module RuboCop
         ].freeze
 
         def investigate(processed_source)
-          return unless processed_source.ast
+          return if processed_source.blank?
           max = cop_config['Max']
           check_nesting_level(processed_source.ast, max, 0)
         end

data/lib/rubocop/cop/metrics/line_length.rb

@@ -10,6 +10,7 @@ module RuboCop
       class LineLength < Cop
         include ConfigurableMax
         include IgnoredPattern
+        include RangeHelp
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'.freeze
 
@@ -99,7 +100,8 @@ module RuboCop
         end
 
         def allowed_uri_position?(line, uri_range)
-          uri_range.begin < max && uri_range.end == line.length
+          uri_range.begin < max &&
+            (uri_range.end == line.length || uri_range.end == line.length - 1)
         end
 
         def find_excessive_uri_range(line)
@@ -126,7 +128,8 @@ module RuboCop
         end
 
         def uri_regexp
-          @regexp ||= URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
+          @uri_regexp ||=
+            URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
         end
 
         def check_directive_line(line, index)

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

@@ -65,6 +65,10 @@ module RuboCop
       def within?(inner, outer)
         inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
       end
+
+      def end_of_line_comment(line)
+        processed_source.find_comment { |c| c.loc.line == line }
+      end
     end
   end
 end

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

@@ -61,7 +61,7 @@ module RuboCop
       alias unrecognized_style_detected no_acceptable_style!
 
       def style
-        @enforced_style ||= begin
+        @style ||= begin
           s = cop_config[style_parameter_name].to_sym
           unless supported_styles.include?(s)
             raise "Unknown style #{s} selected!"

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

@@ -21,6 +21,10 @@ module RuboCop
         end
       end
 
+      def stripped_source_upto(index)
+        processed_source[0..index].map(&:strip)
+      end
+
       def_node_matcher :non_public_modifier?, <<-PATTERN
         (send nil? {:private :protected} ({def defs} ...))
       PATTERN

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

@@ -23,9 +23,17 @@ module RuboCop
         end
       end
 
-      def preceding_comment?(n1, n2)
-        n1 && n2 && precede?(n2, n1) &&
-          comment_line?(n2.loc.expression.source)
+      # The args node1 & node2 may represent a RuboCop::AST::Node
+      # or a Parser::Source::Comment. Both respond to #loc.
+      def preceding_comment?(node1, node2)
+        node1 && node2 && precede?(node2, node1) &&
+          comment_line?(node2.loc.expression.source)
+      end
+
+      # The args node1 & node2 may represent a RuboCop::AST::Node
+      # or a Parser::Source::Comment. Both respond to #loc.
+      def precede?(node1, node2)
+        node2.loc.line - node1.loc.line == 1
       end
 
       def preceding_lines(node)

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

@@ -8,6 +8,7 @@ module RuboCop
       module EmptyLinesAroundBody
         extend NodePattern::Macros
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG_EXTRA = 'Extra empty line detected at %<kind>s body ' \
                     '%<location>s.'.freeze
@@ -64,8 +65,17 @@ module RuboCop
         end
 
         def check_both(style, first_line, last_line)
-          check_beginning(style, first_line)
-          check_ending(style, last_line)
+          case style
+          when :beginning_only
+            check_beginning(:empty_lines, first_line)
+            check_ending(:no_empty_lines, last_line)
+          when :ending_only
+            check_beginning(:no_empty_lines, first_line)
+            check_ending(:empty_lines, last_line)
+          else
+            check_beginning(style, first_line)
+            check_ending(style, last_line)
+          end
         end
 
         def check_beginning(style, first_line)

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

@@ -6,6 +6,8 @@ module RuboCop
     module EndKeywordAlignment
       include ConfigurableEnforcedStyle
 
+      BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+
       MSG = '`end` at %<end_line>d, %<end_col>d is not aligned with ' \
             '`%<source>s` at %<align_line>d, %<align_col>d.'.freeze
 
@@ -53,13 +55,30 @@ module RuboCop
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)
-        end_alignment_style == :variable &&
+        case end_alignment_style
+        when :variable
           !line_break_before_keyword?(whole_expression, rhs)
+        when :start_of_line
+          true
+        end
       end
 
       def line_break_before_keyword?(whole_expression, rhs)
         rhs.first_line > whole_expression.line
       end
+
+      # Returns the column attribute of the range, except if the range is on
+      # the first line and there's a byte order mark at the beginning of that
+      # line, in which case 1 is subtracted from the column value. This gives
+      # the column as it appears when viewing the file in an editor.
+      def effective_column(range)
+        if range.line == 1 &&
+           @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
+          range.column - 1
+        else
+          range.column
+        end
+      end
     end
   end
 end

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

@@ -21,6 +21,10 @@ module RuboCop
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
+        # TODO: Whether frozen string literals will be the default in Ruby 3.0
+        # or not is still unclear as of February 2018.
+        # It may be necessary to change this code in the future.
+        # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
         return true if ruby_version >= 3.0
         return false unless ruby_version >= 2.3
 

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

@@ -10,7 +10,7 @@ module RuboCop
           true
         end
 
-        def deltas_for_first_pair(*)
+        def deltas_for_first_pair(*_nodes)
           {}
         end
 
@@ -93,7 +93,7 @@ module RuboCop
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*)
+        def deltas_for_first_pair(*_nodes)
           {}
         end
 

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for obtaining source ranges from regexp matches
     module MatchRange
+      include RangeHelp
+
       private
 
       # Return a new `Range` covering the first matching group number for each

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

@@ -221,6 +221,12 @@ module RuboCop
         node.source_range.begin_pos > ancestor.loc.begin.begin_pos &&
           node.source_range.end_pos < ancestor.loc.end.end_pos
       end
+
+      def within_node?(inner, outer)
+        o = outer.is_a?(AST::Node) ? outer.source_range : outer
+        i = inner.is_a?(AST::Node) ? inner.source_range : inner
+        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
+      end
     end
   end
 end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module provides a list of methods that are either in the NilClass,
+    # or in the cop's configuration parameter Whitelist.
+    module NilMethods
+      private
+
+      def nil_methods
+        nil.methods + whitelist
+      end
+
+      def whitelist
+        cop_config['Whitelist'].map(&:to_sym)
+      end
+    end
+  end
+end

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for handling percent literals.
     module PercentLiteral
+      include RangeHelp
+
       PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
 
       private
@@ -38,7 +40,7 @@ module RuboCop
         escape = words.any? { |w| needs_escaping?(w.children[0]) }
         char = char.upcase if escape
         delimiters = preferred_delimiters_for("%#{char}")
-        contents = autocorrect_words(words, escape, node.first_line, delimiters)
+        contents = new_contents(node, escape, delimiters)
 
         lambda do |corrector|
           corrector.replace(
@@ -48,21 +50,67 @@ module RuboCop
         end
       end
 
-      def autocorrect_words(word_nodes, escape, base_line_number, delimiters)
-        previous_node_line_number = base_line_number
-        word_nodes.map do |node|
-          number_of_line_breaks = node.first_line - previous_node_line_number
-          line_breaks = "\n" * number_of_line_breaks
-          previous_node_line_number = node.first_line
-          content = node.children.first.to_s
+      def new_contents(node, escape, delimiters)
+        if node.multiline?
+          autocorrect_multiline_words(node, escape, delimiters)
+        else
+          autocorrect_words(node, escape, delimiters)
+        end
+      end
+
+      def autocorrect_multiline_words(node, escape, delimiters)
+        base_line_number = node.first_line
+        previous_line_number = base_line_number
+        contents = node.children.map do |word_node|
+          line_breaks = line_breaks(word_node,
+                                    node.source,
+                                    previous_line_number,
+                                    base_line_number)
+          previous_line_number = word_node.first_line
+          content = escaped_content(word_node, escape, delimiters)
+          line_breaks + content
+        end
+        contents << end_content(node.source)
+        contents.join('')
+      end
+
+      def autocorrect_words(node, escape, delimiters)
+        node.children.map do |word_node|
+          content = word_node.children.first.to_s
           content = escape ? escape_string(content) : content
           delimiters.each do |delimiter|
             content.gsub!(delimiter, "\\#{delimiter}")
           end
-          line_breaks + content
+          content
         end.join(' ')
       end
 
+      def line_breaks(node, source, previous_line_number, base_line_number)
+        source_in_lines = source.split("\n")
+        if node.first_line == previous_line_number
+          node.first_line == base_line_number ? '' : ' '
+        else
+          begin_line_number = previous_line_number - base_line_number + 1
+          end_line_number = node.first_line - base_line_number + 1
+          lines = source_in_lines[begin_line_number...end_line_number]
+          "\n" + lines.join("\n").split(node.source).first
+        end
+      end
+
+      def escaped_content(word_node, escape, delimiters)
+        content = word_node.children.first.to_s
+        content = escape_string(content) if escape
+        delimiters.each do |delimiter|
+          content.gsub!(delimiter, "\\#{delimiter}")
+        end
+        content
+      end
+
+      def end_content(source)
+        result = /\A(\s*)\]/.match(source.split("\n").last)
+        ("\n" + result[1]) if result
+      end
+
       def ensure_valid_preferred_delimiters
         invalid = preferred_delimiters_config.keys -
                   (PERCENT_LITERAL_TYPES + %w[default])