rubocop 1.4.1 → 1.6.0

data/lib/rubocop/cop/cop.rb

@@ -27,7 +27,7 @@ module RuboCop
       def add_offense(node_or_range, location: :expression, message: nil, severity: nil, &block)
         @v0_argument = node_or_range
         range = find_location(node_or_range, location)
-        if block.nil? && !autocorrect?
+        if block.nil? && !support_autocorrect?
           super(range, message: message, severity: severity)
         else
           super(range, message: message, severity: severity) do |corrector|
@@ -136,7 +136,7 @@ module RuboCop
       end
 
       def correction_lambda
-        return unless correction_strategy == :attempt_correction && support_autocorrect?
+        return unless support_autocorrect?
 
         dedup_on_node(@v0_argument) do
           autocorrect(@v0_argument)

data/lib/rubocop/cop/correctors/string_literal_corrector.rb

@@ -7,16 +7,14 @@ module RuboCop
       extend Util
 
       class << self
-        def correct(node, style)
+        def correct(corrector, node, style)
           return if node.dstr_type?
 
-          lambda do |corrector|
-            str = node.str_content
-            if style == :single_quotes
-              corrector.replace(node, to_string_literal(str))
-            else
-              corrector.replace(node, str.inspect)
-            end
+          str = node.str_content
+          if style == :single_quotes
+            corrector.replace(node, to_string_literal(str))
+          else
+            corrector.replace(node, str.inspect)
           end
         end
       end

data/lib/rubocop/cop/generator.rb

@@ -139,7 +139,7 @@ module RuboCop
                                     badge: badge,
                                     version_added: version_added)
 
-        injector.inject do
+        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity
           output.puts(format(CONFIGURATION_ADDED_MESSAGE,
                              configuration_file_path: config_file_path))
         end

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether method definitions are
-      # separated by one empty line.
+      # This cop checks whether class/module/method definitions are
+      # separated by one or more empty lines.
       #
       # `NumberOfEmptyLines` can be an integer (default is 1) or
       # an array (e.g. [1, 2]) to specify a minimum and maximum
       # number of empty lines permitted.
       #
       # `AllowAdjacentOneLineDefs` configures whether adjacent
-      # one-line method definitions are considered an offense.
+      # one-line definitions are considered an offense.
       #
       # @example EmptyLineBetweenMethodDefs: true (default)
       #   # checks for empty lines between method definitions.

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

@@ -45,7 +45,8 @@ module RuboCop
         MSG = 'Empty line detected around arguments.'
 
         def on_send(node)
-          return if node.single_line? || node.arguments.empty?
+          return if node.single_line? || node.arguments.empty? ||
+                    receiver_and_method_call_on_different_lines?(node)
 
           extra_lines(node) do |range|
             add_offense(range) do |corrector|
@@ -57,6 +58,10 @@ module RuboCop
 
         private
 
+        def receiver_and_method_call_on_different_lines?(node)
+          node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
+        end
+
         def empty_lines(node)
           lines = processed_lines(node)
           lines.select! { |code, _| code.empty? }

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

@@ -84,7 +84,7 @@ module RuboCop
         private
 
         def next_line_empty?(line)
-          processed_source[line].blank?
+          processed_source[line].nil? || processed_source[line].blank?
         end
 
         def require_empty_line?(node)

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

@@ -37,14 +37,14 @@ module RuboCop
       #   # good
       #   puts 'Hello' # Return character is CR+LF on all platfoms.
       #
-      class EndOfLine < Cop
+      class EndOfLine < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
         MSG_DETECTED = 'Carriage return character detected.'
         MSG_MISSING = 'Carriage return character missing.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           last_line = last_line(processed_source)
 
           processed_source.raw_source.each_line.with_index do |line, index|
@@ -54,9 +54,9 @@ module RuboCop
             next unless msg
             next if unimportant_missing_cr?(index, last_line, line)
 
-            range =
-              source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, location: range, message: msg)
+            range = source_range(processed_source.buffer, index + 1, 0, line.length)
+
+            add_offense(range, message: msg)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break

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

@@ -207,8 +207,13 @@ module RuboCop
         PATTERN
 
         def base_range(send_node, arg_node)
-          range_between(send_node.source_range.begin_pos,
-                        arg_node.source_range.begin_pos)
+          parent = send_node.parent
+          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+                         send_node.parent
+                       else
+                         send_node
+                       end
+          range_between(start_node.source_range.begin_pos, arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this

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

@@ -69,6 +69,7 @@ module RuboCop
           return unless outermost_send
           return unless outermost_send.loc.end
           return unless heredoc_arg.first_line != outermost_send.loc.end.line
+          return if subsequent_closing_parentheses_in_same_line?(outermost_send)
 
           add_offense(outermost_send.loc.end) do |corrector|
             autocorrect(corrector, outermost_send)
@@ -160,6 +161,17 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def subsequent_closing_parentheses_in_same_line?(outermost_send)
+          last_arg_of_outer_send = outermost_send.last_argument
+          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+                              (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
+
+          end_of_outer_send = outermost_send.loc.end
+
+          end_of_outer_send.line == end_of_last_arg_of_outer_send.line &&
+            end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
+        end
+
         def fix_closing_parenthesis(node, corrector)
           remove_incorrect_closing_paren(node, corrector)
           add_correct_closing_paren(node, corrector)

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

@@ -58,12 +58,13 @@ module RuboCop
       #     bar: "0000000000",
       #     baz: "0000000000",
       #   }
-      class LineLength < Cop
+      class LineLength < Base
         include CheckLineBreakable
         include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
         include LineLengthHelp
+        extend AutoCorrector
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
@@ -78,28 +79,16 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
 
-        def investigate(processed_source)
+        def on_new_investigation
           check_for_breakable_semicolons(processed_source)
         end
 
-        def investigate_post_walk(processed_source)
+        def on_investigation_end
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
           end
         end
 
-        def correctable?
-          super && !breakable_range.nil?
-        end
-
-        def autocorrect(range)
-          return if range.nil?
-
-          lambda do |corrector|
-            corrector.insert_before(range, "\n")
-          end
-        end
-
         private
 
         attr_accessor :breakable_range
@@ -203,8 +192,9 @@ module RuboCop
 
           self.breakable_range = breakable_range_by_line_index[line_index]
 
-          add_offense(breakable_range, location: loc, message: message) do
+          add_offense(loc, message: message) do |corrector|
             self.max = line_length(line)
+            corrector.insert_before(breakable_range, "\n") unless breakable_range.nil?
           end
         end
 

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

@@ -77,7 +77,7 @@ module RuboCop
 
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
-                             @base.column + extra_indentation(given_style)
+                             @base.column + extra_indentation(given_style, node.parent)
                            else
                              indentation(lhs) + correct_indentation(node)
                            end
@@ -85,9 +85,13 @@ module RuboCop
           rhs if @column_delta.nonzero?
         end
 
-        def extra_indentation(given_style)
+        def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver
-            configured_indentation_width
+            if parent && (parent.splat_type? || parent.kwsplat_type?)
+              configured_indentation_width - parent.loc.operator.length
+            else
+              configured_indentation_width
+            end
           else
             0
           end

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

@@ -23,10 +23,11 @@ module RuboCop
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          parent = node.parent
-          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless node
+          return if string_or_regex?(node.parent)
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
+          return unless node.loc.begin && node.loc.end
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -35,6 +36,10 @@ module RuboCop
 
         private
 
+        def string_or_regex?(node)
+          node&.dstr_type? || node&.regexp_type?
+        end
+
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']

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

@@ -40,7 +40,7 @@ module RuboCop
       #                     do_something
       #                   end
       #
-      class NoReturnInBeginEndBlocks < Cop
+      class NoReturnInBeginEndBlocks < Base
         MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
 
         def on_lvasgn(node)

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

@@ -8,6 +8,14 @@ module RuboCop
       # given by `ruby -cw` prior to Ruby 2.6:
       # "shadowing outer local variable - foo".
       #
+      # NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
+      # because `Ractor` should not access outer variables.
+      # eg. following syle is encouraged:
+      #
+      #   worker_id, pipe = env
+      #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
+      #   end
+      #
       # @example
       #
       #   # bad
@@ -34,12 +42,17 @@ module RuboCop
       class ShadowingOuterLocalVariable < Base
         MSG = 'Shadowing outer local variable - `%<variable>s`.'
 
+        def_node_matcher :ractor_block?, <<~PATTERN
+          (block (send (const nil? :Ractor) :new ...) ...)
+        PATTERN
+
         def self.joining_forces
           VariableForce
         end
 
         def before_declaring_variable(variable, variable_table)
           return if variable.should_be_unused?
+          return if ractor_block?(variable.scope.node)
 
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for a block that is known to need more positional
+      # block arguments than are given (by default this is configured for
+      # `Enumerable` methods needing 2 arguments). Optional arguments are allowed,
+      # although they don't generally make sense as the default value will
+      # be used. Blocks that have no receiver, or take splatted arguments
+      # (ie. `*args`) are always accepted.
+      #
+      # Keyword arguments (including `**kwargs`) do not get counted towards
+      # this, as they are not used by the methods in question.
+      #
+      # NOTE: This cop matches for method names only and hence cannot tell apart
+      # methods with same name in different classes.
+      #
+      # Method names and their expected arity can be configured like this:
+      #
+      # Methods:
+      #   inject: 2
+      #   reduce: 2
+      #
+      # @example
+      #   # bad
+      #   values.reduce {}
+      #   values.min { |a| a }
+      #   values.sort { |a; b| a + b }
+      #
+      #   # good
+      #   values.reduce { |memo, obj| memo << obj }
+      #   values.min { |a, b| a <=> b }
+      #   values.sort { |*x| x[0] <=> x[1] }
+      #
+      class UnexpectedBlockArity < Base
+        MSG = '`%<method>s` expects at least %<expected>i positional arguments, got %<actual>i.'
+
+        def on_block(node)
+          return if acceptable?(node)
+
+          expected = expected_arity(node.method_name)
+          actual = arg_count(node)
+          return if actual >= expected
+
+          message = format(MSG, method: node.method_name, expected: expected, actual: actual)
+          add_offense(node, message: message)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def methods
+          cop_config.fetch('Methods', [])
+        end
+
+        def acceptable?(node)
+          !(included_method?(node.method_name) && node.receiver)
+        end
+
+        def included_method?(name)
+          methods.key?(name.to_s)
+        end
+
+        def expected_arity(method)
+          cop_config['Methods'][method.to_s]
+        end
+
+        def arg_count(node)
+          return node.children[1] if node.numblock_type? # the maximum numbered param for the block
+
+          # Only `arg`, `optarg` and `mlhs` (destructuring) count as arguments that
+          # can be used. Keyword arguments are not used for these methods so are
+          # ignored.
+          node.arguments.count do |arg|
+            return Float::INFINITY if arg.restarg_type?
+
+            arg.arg_type? || arg.optarg_type? || arg.mlhs_type?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -67,7 +67,10 @@ module RuboCop
         MSG_INDEX = 'Do not return an element of the accumulator in `%<method>s`.'
 
         def_node_matcher :reduce_with_block?, <<~PATTERN
-          (block (send _recv {:reduce :inject} ...) (args arg+) ...)
+          {
+            (block (send _recv {:reduce :inject} ...) args ...)
+            (numblock (send _recv {:reduce :inject} ...) ...)
+          }
         PATTERN
 
         def_node_matcher :accumulator_index?, <<~PATTERN
@@ -106,9 +109,11 @@ module RuboCop
 
         def on_block(node)
           return unless reduce_with_block?(node)
+          return unless node.argument_list.length >= 2
 
           check_return_values(node)
         end
+        alias on_numblock on_block
 
         private
 
@@ -146,7 +151,7 @@ module RuboCop
         end
 
         def block_arg_name(node, index)
-          node.arguments[index].node_parts[0]
+          node.argument_list[index].name
         end
 
         # Look for an index of the accumulator being returned, except where the index

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

@@ -7,6 +7,27 @@ module RuboCop
       # configured maximum. The ABC size is based on assignments, branches
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
       # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+      #
+      # You can have repeated "attributes" calls count as a single "branch".
+      # For this purpose, attributes are any method with no argument; no attempt
+      # is meant to distinguish actual `attr_reader` from other methods.
+      #
+      # @example CountRepeatedAttributes: false (default is true)
+      #
+      #    # `model` and `current_user`, refenced 3 times each,
+      #    # are each counted as only 1 branch each if
+      #    # `CountRepeatedAttributes` is set to 'false'
+      #
+      #    def search
+      #      @posts = model.active.visible_by(current_user)
+      #                .search(params[:q])
+      #      @posts = model.some_process(@posts, current_user)
+      #      @posts = model.another_process(@posts, current_user)
+      #
+      #      render 'pages/search/page'
+      #    end
+      #
+      # This cop also takes into account `IgnoredMethods` (defaults to `[]`)
       class AbcSize < Base
         include MethodComplexity
 
@@ -16,7 +37,10 @@ module RuboCop
         private
 
         def complexity(node)
-          Utils::AbcSizeCalculator.calculate(node)
+          Utils::AbcSizeCalculator.calculate(
+            node,
+            discount_repeated_attributes: !cop_config['CountRepeatedAttributes']
+          )
         end
       end
     end