rubocop 0.76.0 → 1.50.0

data/lib/rubocop/cop/style/semicolon.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for multiple expressions placed on the same line.
+      # Checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
       #
       # This cop has `AllowAsExpressionSeparator` configuration option.
@@ -26,74 +26,129 @@ module RuboCop
       # @example AllowAsExpressionSeparator: true
       #   # good
       #   foo = 1; bar = 2
-      class Semicolon < Cop
+      class Semicolon < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use semicolons to terminate expressions.'
 
-        def investigate(processed_source)
-          return if processed_source.blank?
+        def self.autocorrect_incompatible_with
+          [Style::SingleLineMethods]
+        end
 
-          @processed_source = processed_source
+        def on_new_investigation
+          return if processed_source.blank? || !processed_source.raw_source.include?(';')
 
           check_for_line_terminator_or_opener
         end
 
         def on_begin(node)
           return if cop_config['AllowAsExpressionSeparator']
+          return unless node.source.include?(';')
 
           exprs = node.children
 
           return if exprs.size < 2
 
-          # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map(&:first_line)
-          lines = exprs_lines.group_by(&:itself)
-
-          lines.each do |line, expr_on_line|
+          expressions_per_line(exprs).each do |line, expr_on_line|
             # Every line with more than one expression on it is a
             # potential offense
             next unless expr_on_line.size > 1
 
-            # TODO: Find the correct position of the semicolon. We don't know
-            # if the first semicolon on the line is a separator of
-            # expressions. It's just a guess.
-            column = @processed_source[line - 1].index(';')
-
-            next unless column
-
-            convention_on(line, column, false)
+            find_semicolon_positions(line) { |pos| register_semicolon(line, pos, true) }
           end
         end
 
-        def autocorrect(range)
-          return unless range
-
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def check_for_line_terminator_or_opener
-          each_semicolon { |line, column| convention_on(line, column, true) }
+          # Make the obvious check first
+          return unless processed_source.raw_source.include?(';')
+
+          each_semicolon do |line, column, token_before_semicolon|
+            register_semicolon(line, column, false, token_before_semicolon)
+          end
         end
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column if tokens.last.semicolon?
-            yield line, tokens.first.column if tokens.first.semicolon?
+            semicolon_pos = semicolon_position(tokens)
+            after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
+
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
           end
         end
 
         def tokens_for_lines
-          @processed_source.tokens.group_by(&:line)
+          processed_source.tokens.group_by(&:line)
+        end
+
+        def semicolon_position(tokens)
+          if tokens.last.semicolon?
+            -1
+          elsif tokens.first.semicolon?
+            0
+          elsif exist_semicolon_before_right_curly_brace?(tokens)
+            -3
+          elsif exist_semicolon_after_left_curly_brace?(tokens)
+            2
+          end
+        end
+
+        def exist_semicolon_before_right_curly_brace?(tokens)
+          tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
         end
 
-        def convention_on(line, column, autocorrect)
-          range = source_range(@processed_source.buffer, line, column)
-          # Don't attempt to autocorrect if semicolon is separating statements
-          # on the same line
-          add_offense(autocorrect ? range : nil, location: range)
+        def exist_semicolon_after_left_curly_brace?(tokens)
+          tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
+        end
+
+        def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
+          range = source_range(processed_source.buffer, line, column)
+
+          add_offense(range) do |corrector|
+            if after_expression
+              corrector.replace(range, "\n")
+            else
+              # Prevents becoming one range instance with subsequent line when endless range
+              # without parentheses.
+              # See: https://github.com/rubocop/rubocop/issues/10791
+              if token_before_semicolon&.regexp_dots?
+                range_node = find_range_node(token_before_semicolon)
+                corrector.wrap(range_node, '(', ')') if range_node
+              end
+
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def expressions_per_line(exprs)
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map(&:first_line)
+          exprs_lines.group_by(&:itself)
+        end
+
+        def find_semicolon_positions(line)
+          # Scan for all the semicolons on the line
+          semicolons = processed_source[line - 1].enum_for(:scan, ';')
+          semicolons.each do
+            yield Regexp.last_match.begin(0)
+          end
+        end
+
+        def find_range_node(token_before_semicolon)
+          range_nodes.detect do |range_node|
+            range_node.source_range.contains?(token_before_semicolon.pos)
+          end
+        end
+
+        def range_nodes
+          return @range_nodes if instance_variable_defined?(:@range_nodes)
+
+          ast = processed_source.ast
+          @range_nodes = ast.range_type? ? [ast] : []
+          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
         end
       end
     end

data/lib/rubocop/cop/style/send.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of the send method.
+      # Checks for the use of the send method.
       #
       # @example
       #   # bad
@@ -13,16 +13,14 @@ module RuboCop
       #   # good
       #   Foo.__send__(:bar)
       #   quuz.public_send(:fred)
-      class Send < Cop
-        MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
-              '`send`.'
-
-        def_node_matcher :sending?, '({send csend} _ :send ...)'
+      class Send < Base
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
+        RESTRICT_ON_SEND = %i[send].freeze
 
         def on_send(node)
-          return unless sending?(node) && node.arguments?
+          return unless node.arguments?
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
         alias on_csend on_send
       end

data/lib/rubocop/cop/style/signal_exception.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `fail` and `raise`.
+      # Checks for uses of `fail` and `raise`.
       #
       # @example EnforcedStyle: only_raise (default)
       #   # The `only_raise` style enforces the sole use of `raise`.
@@ -104,21 +104,20 @@ module RuboCop
       #
       #   explicit_receiver.fail
       #   explicit_receiver.raise
-      class SignalException < Cop
+      class SignalException < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
-        RAISE_MSG = 'Use `raise` instead of `fail` to ' \
-                    'rethrow exceptions.'
+        RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
 
-        def_node_matcher :kernel_call?, '(send (const nil? :Kernel) %1 ...)'
-        def_node_search :custom_fail_methods,
-                        '{(def :fail ...) (defs _ :fail ...)}'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
-        def investigate(processed_source)
-          ast = processed_source.ast
-          @custom_fail_defined = ast && custom_fail_methods(ast).any?
-        end
+        # @!method kernel_call?(node, name)
+        def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
+
+        # @!method custom_fail_methods(node)
+        def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
         def on_rescue(node)
           return unless style == :semantic
@@ -137,7 +136,7 @@ module RuboCop
           when :semantic
             check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
-            return if @custom_fail_defined
+            return if custom_fail_defined?
 
             check_send(:fail, node)
           when :only_fail
@@ -145,22 +144,15 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            name =
-              case style
-              when :semantic
-                command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
-              when :only_raise then 'raise'
-              when :only_fail then 'fail'
-              end
-
-            corrector.replace(node.loc.selector, name)
-          end
-        end
-
         private
 
+        def custom_fail_defined?
+          return @custom_fail_defined if defined?(@custom_fail_defined)
+
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
         def message(method_name)
           case style
           when :semantic
@@ -178,8 +170,9 @@ module RuboCop
           each_command_or_kernel_call(method_name, node) do |send_node|
             next if ignored_node?(send_node)
 
-            add_offense(send_node,
-                        location: :selector, message: message(method_name))
+            add_offense(send_node.loc.selector, message: message(method_name)) do |corrector|
+              autocorrect(corrector, send_node)
+            end
             ignore_node(send_node)
           end
         end
@@ -187,17 +180,31 @@ module RuboCop
         def check_send(method_name, node)
           return unless node && command_or_kernel_call?(method_name, node)
 
-          add_offense(node, location: :selector, message: message(method_name))
+          add_offense(node.loc.selector, message: message(method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          name =
+            case style
+            when :semantic
+              command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
+            when :only_raise then 'raise'
+            when :only_fail then 'fail'
+            end
+
+          corrector.replace(node.loc.selector, name)
         end
 
         def command_or_kernel_call?(name, node)
+          return unless node.method?(name)
+
           node.command?(name) || kernel_call?(node, name)
         end
 
         def allow(method_name, node)
-          each_command_or_kernel_call(method_name, node) do |send_node|
-            ignore_node(send_node)
-          end
+          each_command_or_kernel_call(method_name, node) { |send_node| ignore_node(send_node) }
         end
 
         def each_command_or_kernel_call(method_name, node)

data/lib/rubocop/cop/style/single_argument_dig.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sometimes using dig method ends up with just a single
+      # argument. In such cases, dig should be replaced with [].
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
+      # @example
+      #   # bad
+      #   { key: 'value' }.dig(:key)
+      #   [1, 2, 3].dig(0)
+      #
+      #   # good
+      #   { key: 'value' }[:key]
+      #   [1, 2, 3][0]
+      #
+      #   # good
+      #   { key1: { key2: 'value' } }.dig(:key1, :key2)
+      #   [1, [2, [3]]].dig(1, 1)
+      #
+      #   # good
+      #   keys = %i[key1 key2]
+      #   { key1: { key2: 'value' } }.dig(*keys)
+      #
+      class SingleArgumentDig < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
+        RESTRICT_ON_SEND = %i[dig].freeze
+
+        # @!method single_argument_dig?(node)
+        def_node_matcher :single_argument_dig?, <<~PATTERN
+          (send _ :dig $!splat)
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+
+          expression = single_argument_dig?(node)
+          return unless expression
+          return if expression.forwarded_args_type?
+
+          receiver = node.receiver.source
+          argument = expression.source
+
+          message = format(MSG, receiver: receiver, argument: argument, original: node.source)
+          add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            correct_access = "#{receiver}[#{argument}]"
+            corrector.replace(node, correct_access)
+          end
+
+          ignore_node(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/single_line_block_params.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether the block parameters of a single-line
+      # Checks whether the block parameters of a single-line
       # method accepting a block match the names specified via configuration.
       #
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
@@ -28,27 +28,52 @@ module RuboCop
       #   foo.reduce do |c, d|
       #     c + d
       #   end
-      class SingleLineBlockParams < Cop
+      class SingleLineBlockParams < Base
+        extend AutoCorrector
+
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.single_line?
 
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          return if args_match?(node.send_node.method_name, node.arguments)
+          method_name = node.method_name
+          return if args_match?(method_name, node.arguments)
+
+          preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
+          joined_block_arguments = preferred_block_arguments.values.join(', ')
+
+          message = format(MSG, method: method_name, params: joined_block_arguments)
 
-          add_offense(node.arguments)
+          add_offense(node.arguments, message: message) do |corrector|
+            autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          end
         end
 
         private
 
-        def message(node)
-          method_name = node.parent.send_node.method_name
-          arguments   = target_args(method_name).join(', ')
+        def build_preferred_arguments_map(node, preferred_arguments)
+          preferred_arguments_map = {}
+          node.arguments.each_with_index do |current_lvar, index|
+            preferred_argument = preferred_arguments[index]
+            current_argument = current_lvar.source
+            preferred_argument = "_#{preferred_argument}" if current_argument.start_with?('_')
+            preferred_arguments_map[current_argument] = preferred_argument
+          end
+
+          preferred_arguments_map
+        end
+
+        def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          corrector.replace(node.arguments, "|#{joined_block_arguments}|")
 
-          format(MSG, method: method_name, params: arguments)
+          node.each_descendant(:lvar) do |lvar|
+            if (preferred_lvar = preferred_block_arguments[lvar.source])
+              corrector.replace(lvar, preferred_lvar)
+            end
+          end
         end
 
         def eligible_arguments?(node)
@@ -56,8 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver &&
-            method_names.include?(node.send_node.method_name)
+          node.receiver && method_names.include?(node.method_name)
         end
 
         def methods
@@ -83,11 +107,11 @@ module RuboCop
 
           # Prepending an underscore to mark an unused parameter is allowed, so
           # we remove any leading underscores before comparing.
-          actual_args_no_underscores = actual_args.map do |arg|
-            arg.to_s.sub(/^_+/, '')
-          end
+          actual_args_no_underscores = actual_args.map { |arg| arg.to_s.sub(/^_+/, '') }
 
-          actual_args_no_underscores == target_args(method_name)
+          # Allow the arguments if the names match but not all are given
+          expected_args = target_args(method_name).first(actual_args_no_underscores.size)
+          actual_args_no_underscores == expected_args
         end
       end
     end

data/lib/rubocop/cop/style/single_line_methods.rb

@@ -3,9 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for single-line method definitions that contain a body.
+      # Checks for single-line method definitions that contain a body.
       # It will accept single-line methods with no body.
       #
+      # Endless methods added in Ruby 3.0 are also accepted by this cop.
+      #
+      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
+      # `allow_always`, single-line methods will be autocorrected to endless
+      # methods if there is only one statement in the body.
+      #
       # @example
       #   # bad
       #   def some_method; body end
@@ -15,6 +21,7 @@ module RuboCop
       #   # good
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
+      #   def some_method() = body
       #
       # @example AllowIfMethodIsEmpty: true (default)
       #   # good
@@ -24,43 +31,76 @@ module RuboCop
       #   # bad
       #   def no_op; end
       #
-      class SingleLineMethods < Cop
+      class SingleLineMethods < Base
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
+        NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = %i[return break next].freeze
 
         def on_def(node)
           return unless node.single_line?
+          return if node.endless?
           return if allow_empty? && !node.body
 
-          add_offense(node)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            each_part(node.body) do |part|
-              LineBreakCorrector.break_line_before(
-                range: part, node: node, corrector: corrector,
-                configured_width: configured_indentation_width
-              )
-            end
-
-            LineBreakCorrector.break_line_before(
-              range: node.loc.end, node: node, corrector: corrector,
-              indent_steps: 0, configured_width: configured_indentation_width
-            )
+        private
 
-            move_comment(node, corrector)
+        def autocorrect(corrector, node)
+          if correct_to_endless?(node.body)
+            correct_to_endless(corrector, node)
+          else
+            correct_to_multiline(corrector, node)
           end
         end
 
-        private
-
         def allow_empty?
           cop_config['AllowIfMethodIsEmpty']
         end
 
+        def correct_to_endless?(body_node)
+          return false if target_ruby_version < 3.0
+          return false if disallow_endless_method_style?
+          return false unless body_node
+          return false if body_node.parent.assignment_method? ||
+                          NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
+
+          !(body_node.begin_type? || body_node.kwbegin_type?)
+        end
+
+        def correct_to_multiline(corrector, node)
+          if (body = node.body) && body.begin_type? && body.parenthesized_call?
+            break_line_before(corrector, node, body)
+          else
+            each_part(body) do |part|
+              break_line_before(corrector, node, part)
+            end
+          end
+
+          break_line_before(corrector, node, node.loc.end, indent_steps: 0)
+
+          move_comment(node, corrector)
+        end
+
+        def correct_to_endless(corrector, node)
+          self_receiver = node.self_receiver? ? 'self.' : ''
+          arguments = node.arguments.any? ? node.arguments.source : '()'
+          body_source = method_body_source(node.body)
+          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+
+          corrector.replace(node, replacement)
+        end
+
+        def break_line_before(corrector, node, range, indent_steps: 1)
+          LineBreakCorrector.break_line_before(
+            range: range, node: node, corrector: corrector,
+            configured_width: configured_indentation_width, indent_steps: indent_steps
+          )
+        end
+
         def each_part(body)
           return unless body
 
@@ -73,10 +113,32 @@ module RuboCop
 
         def move_comment(node, corrector)
           LineBreakCorrector.move_comment(
-            eol_comment: end_of_line_comment(node.source_range.line),
+            eol_comment: processed_source.comment_at_line(node.source_range.line),
             node: node, corrector: corrector
           )
         end
+
+        def method_body_source(method_body)
+          if require_parentheses?(method_body)
+            arguments_source = method_body.arguments.map(&:source).join(', ')
+            body_source = "#{method_body.method_name}(#{arguments_source})"
+
+            method_body.receiver ? "#{method_body.receiver.source}.#{body_source}" : body_source
+          else
+            method_body.source
+          end
+        end
+
+        def require_parentheses?(method_body)
+          method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
+        end
+
+        def disallow_endless_method_style?
+          endless_method_config = config.for_cop('Style/EndlessMethod')
+          return false unless endless_method_config['Enabled']
+
+          endless_method_config['EnforcedStyle'] == 'disallow'
+        end
       end
     end
   end

data/lib/rubocop/cop/style/slicing_with_range.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that arrays are sliced with endless ranges instead of
+      # `ary[start..-1]` on Ruby 2.6+.
+      #
+      # @safety
+      #   This cop is unsafe because `x..-1` and `x..` are only guaranteed to
+      #   be equivalent for `Array#[]`, `String#[]`, and the cop cannot determine what class
+      #   the receiver is.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   sum = proc { |ary| ary.sum }
+      #   sum[-3..-1] # => -6
+      #   sum[-3..] # Hangs forever
+      #   ----
+      #
+      # @example
+      #   # bad
+      #   items[1..-1]
+      #
+      #   # good
+      #   items[1..]
+      class SlicingWithRange < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer ary[n..] over ary[n..-1].'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        # @!method range_till_minus_one?(node)
+        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
+
+        def on_send(node)
+          return unless node.arguments.count == 1
+          return unless range_till_minus_one?(node.arguments.first)
+
+          add_offense(node.first_argument) do |corrector|
+            corrector.remove(node.first_argument.end)
+          end
+        end
+      end
+    end
+  end
+end