rubocop 1.9.1 → 1.22.3

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

@@ -59,8 +59,8 @@ module RuboCop
 
         def check(send_node)
           return if previous_line_comment?(send_node)
-          return unless grouped_style? && sibling_accessors(send_node).size > 1 ||
-                        separated_style? && send_node.arguments.size > 1
+          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+                        (separated_style? && send_node.arguments.size > 1)
 
           message = message(send_node)
           add_offense(send_node, message: message) do |corrector|
@@ -129,9 +129,7 @@ module RuboCop
         end
 
         def group_accessors(node, accessors)
-          accessor_names = accessors.flat_map do |accessor|
-            accessor.arguments.map(&:source)
-          end
+          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }
 
           "#{node.method_name} #{accessor_names.join(', ')}"
         end

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

@@ -27,10 +27,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
-        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
-                           '%<current>s.'
-        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
-                           '`alias %<current>s`.'
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %<current>s.'
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of `alias %<current>s`.'
 
         RESTRICT_ON_SEND = %i[alias_method].freeze
 
@@ -52,9 +50,7 @@ module RuboCop
               autocorrect(corrector, node)
             end
           elsif node.children.none? { |arg| bareword?(arg) }
-            add_offense_for_args(node) do |corrector|
-              autocorrect(corrector, node)
-            end
+            add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
           end
         end
 
@@ -75,17 +71,14 @@ module RuboCop
         end
 
         def alias_method_possible?(node)
-          scope_type(node) != :instance_eval &&
-            node.children.none?(&:gvar_type?)
+          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
         end
 
         def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
           preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
-          msg            = format(MSG_SYMBOL_ARGS,
-                                  prefer: preferred_args,
-                                  current: existing_args)
+          msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
           add_offense(arg_ranges.reduce(&:join), message: msg, &block)
         end
 
@@ -145,6 +138,7 @@ module RuboCop
           corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
         end
 
+        # @!method identifier(node)
         def_node_matcher :identifier, <<~PATTERN
           (sym $_)
         PATTERN

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

@@ -7,6 +7,11 @@ module RuboCop
       # `||` instead. It can be configured to check only in conditions or in
       # all contexts.
       #
+      # @safety
+      #   Auto-correction is unsafe because there is a different operator precedence
+      #   between logical operators (`&&` and `||`) and semantic operators (`and` and `or`),
+      #   and that might change the behaviour.
+      #
       # @example EnforcedStyle: always
       #   # bad
       #   foo.save and return
@@ -94,7 +99,9 @@ module RuboCop
 
           return unless correctable_send?(node)
 
-          corrector.replace(whitespace_before_arg(node), '(')
+          whitespace_before_arg_range = whitespace_before_arg(node)
+          corrector.remove(whitespace_before_arg_range)
+          corrector.insert_before(whitespace_before_arg_range, '(')
           corrector.insert_after(node.last_argument, ')')
         end
 

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

@@ -30,6 +30,10 @@ module RuboCop
       #     bar(*args)
       #   end
       #
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
       # @example AllowOnlyRestArgument: false
       #   # bad
       #   # The following code can replace the arguments with `...`,
@@ -38,6 +42,10 @@ module RuboCop
       #     bar(*args)
       #   end
       #
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
       class ArgumentsForwarding < Base
         include RangeHelp
         extend AutoCorrector
@@ -47,14 +55,20 @@ module RuboCop
 
         MSG = 'Use arguments forwarding.'
 
+        # @!method use_rest_arguments?(node)
         def_node_matcher :use_rest_arguments?, <<~PATTERN
-          (args (restarg $_) $...)
+          (args ({restarg kwrestarg} $_) $...)
         PATTERN
 
+        # @!method only_rest_arguments?(node, name)
         def_node_matcher :only_rest_arguments?, <<~PATTERN
-          (send _ _ (splat (lvar %1)))
+          {
+            (send _ _ (splat (lvar %1)))
+            (send _ _ (hash (kwsplat (lvar %1))))
+          }
         PATTERN
 
+        # @!method forwarding_method_arguments?(node, rest_name, block_name, kwargs_name)
         def_node_matcher :forwarding_method_arguments?, <<~PATTERN
           {
             (send _ _
@@ -104,9 +118,7 @@ module RuboCop
           begin_pos = forwarding_method.source_range.begin_pos
           end_pos = forwarding_method.source_range.end_pos
 
-          lvars.all? do |lvar|
-            lvar.source_range.begin_pos.between?(begin_pos, end_pos)
-          end
+          lvars.all? { |lvar| lvar.source_range.begin_pos.between?(begin_pos, end_pos) }
         end
 
         def register_offense_to_forwarding_method_arguments(forwarding_method)

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

@@ -5,9 +5,27 @@ module RuboCop
     module Style
       # This cop enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
       #
-      # This cop is disabled by default because false positive will occur if
-      # the argument of `Array()` is not an array (e.g. Hash, Set),
-      # an array will be returned as an incompatibility result.
+      # The cop is disabled by default due to safety concerns.
+      #
+      # @safety
+      #   This cop is unsafe because a false positive may occur if
+      #   the argument of `Array()` is (or could be) nil or depending
+      #   on how the argument is handled by `Array()` (which can be
+      #   different than just wrapping the argument in an array).
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   [nil]             #=> [nil]
+      #   Array(nil)        #=> []
+      #
+      #   [{a: 'b'}]        #= [{a: 'b'}]
+      #   Array({a: 'b'})   #=> [[:a, 'b']]
+      #
+      #   [Time.now]        #=> [#<Time ...>]
+      #   Array(Time.now)   #=> [14, 16, 14, 16, 9, 2021, 4, 259, true, "EDT"]
+      #   ----
       #
       # @example
       #   # bad
@@ -26,10 +44,12 @@ module RuboCop
         SPLAT_MSG = 'Use `Array(%<arg>s)` instead of `[*%<arg>s]`.'
         CHECK_MSG = 'Use `Array(%<arg>s)` instead of explicit `Array` check.'
 
+        # @!method array_splat?(node)
         def_node_matcher :array_splat?, <<~PATTERN
           (array (splat $_))
         PATTERN
 
+        # @!method unless_array?(node)
         def_node_matcher :unless_array?, <<~PATTERN
           (if
             (send

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

@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Favor `Array#join` over `Array#*`.'
         RESTRICT_ON_SEND = %i[*].freeze
 
+        # @!method join_candidate?(node)
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 
         def on_send(node)

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/AsciiComments
-
 module RuboCop
   module Cop
     module Style
@@ -35,8 +33,7 @@ module RuboCop
           expression    = comment.loc.expression
           first_offense = first_non_ascii_chars(comment.text)
 
-          start_position = expression.begin_pos +
-                           comment.text.index(first_offense)
+          start_position = expression.begin_pos + comment.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
           range_between(start_position, end_position)
@@ -58,4 +55,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Style/AsciiComments

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

@@ -24,9 +24,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
           # check only for method definitions in class/module body
-          return if node.parent &&
-                    !node.parent.class_type? &&
-                    !class_eval?(node.parent)
+          return if node.parent && !node.parent.class_type? && !class_eval?(node.parent)
 
           message = message(node)
           add_offense(node.loc.selector, message: message) do |corrector|
@@ -62,6 +60,7 @@ module RuboCop
           end
         end
 
+        # @!method class_eval?(node)
         def_node_matcher :class_eval?, <<~PATTERN
           (block (send _ {:class_eval :module_eval}) ...)
         PATTERN

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

@@ -19,9 +19,7 @@ module RuboCop
       class AutoResourceCleanup < Base
         MSG = 'Use the block version of `%<class>s.%<method>s`.'
 
-        TARGET_METHODS = {
-          File: :open
-        }.freeze
+        TARGET_METHODS = { File: :open }.freeze
 
         RESTRICT_ON_SEND = TARGET_METHODS.values.freeze
 
@@ -42,8 +40,7 @@ module RuboCop
 
         def cleanup?(node)
           parent = node.parent
-          node.block_argument? ||
-            (parent && (parent.block_type? || !parent.lvasgn_type?))
+          node.block_argument? || (parent && (parent.block_type? || !parent.lvasgn_type?))
         end
       end
     end

data/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class BisectedAttrAccessor
+        # Representation of an `attr_reader`, `attr_writer` or `attr` macro
+        # for use by `Style/BisectedAttrAccessor`.
+        # @api private
+        class Macro
+          include VisibilityHelp
+
+          attr_reader :node, :attrs, :bisection
+
+          def self.macro?(node)
+            node.method?(:attr_reader) || node.method?(:attr_writer) || node.method?(:attr)
+          end
+
+          def initialize(node)
+            @node = node
+            @attrs = node.arguments.map { |attr| [attr.source, attr] }.to_h
+            @bisection = []
+          end
+
+          def bisect(*names)
+            @bisection = attrs.slice(*names).values
+          end
+
+          def attr_names
+            @attr_names ||= attrs.keys
+          end
+
+          def bisected_names
+            bisection.map(&:source)
+          end
+
+          def visibility
+            @visibility ||= node_visibility(node)
+          end
+
+          def reader?
+            node.method?(:attr_reader) || node.method?(:attr)
+          end
+
+          def writer?
+            node.method?(:attr_writer)
+          end
+
+          def all_bisected?
+            rest.none?
+          end
+
+          def rest
+            @rest ||= attr_names - bisected_names
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,47 +19,61 @@ module RuboCop
       #   end
       #
       class BisectedAttrAccessor < Base
-        include VisibilityHelp
+        require_relative 'bisected_attr_accessor/macro'
+
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
 
+        def on_new_investigation
+          @macros_to_rewrite = {}
+        end
+
         def on_class(class_node)
-          VISIBILITY_SCOPES.each do |visibility|
-            reader_names, writer_names = accessor_names(class_node, visibility)
-            next unless reader_names && writer_names
+          @macros_to_rewrite[class_node] = Set.new
+
+          find_macros(class_node.body).each do |_visibility, macros|
+            bisected = find_bisection(macros)
+            next unless bisected.any?
 
-            accessor_macroses(class_node, visibility).each do |macro|
-              check(macro, reader_names, writer_names)
+            macros.each do |macro|
+              attrs = macro.bisect(*bisected)
+              next if attrs.none?
+
+              @macros_to_rewrite[class_node] << macro
+              attrs.each { |attr| register_offense(attr) }
             end
           end
         end
         alias on_sclass on_class
         alias on_module on_class
 
-        private
-
-        def accessor_names(class_node, visibility)
-          reader_names = nil
-          writer_names = nil
-
-          accessor_macroses(class_node, visibility).each do |macro|
-            names = macro.arguments.map(&:source)
-
-            names.each do |name|
-              if attr_reader?(macro)
-                (reader_names ||= Set.new).add(name)
+        # Each offending macro is captured and registered in `on_class` but correction
+        # happens in `after_class` because a macro might have multiple attributes
+        # rewritten from it
+        def after_class(class_node)
+          @macros_to_rewrite[class_node].each do |macro|
+            node = macro.node
+            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+
+            correct(range) do |corrector|
+              if macro.writer?
+                correct_writer(corrector, macro, node, range)
               else
-                (writer_names ||= Set.new).add(name)
+                correct_reader(corrector, macro, node, range)
               end
             end
           end
-
-          [reader_names, writer_names]
         end
+        alias after_sclass after_class
+        alias after_module after_class
 
-        def accessor_macroses(class_node, visibility)
-          class_def = class_node.body
+        private
+
+        def find_macros(class_def)
+          # Find all the macros (`attr_reader`, `attr_writer`, etc.) in the class body
+          # and turn them into `Macro` objects so that they can be processed.
           return [] if !class_def || class_def.def_type?
 
           send_nodes =
@@ -69,66 +83,40 @@ module RuboCop
               class_def.each_child_node(:send)
             end
 
-          send_nodes.select { |node| attr_within_visibility_scope?(node, visibility) }
+          send_nodes.each_with_object([]) do |node, macros|
+            macros << Macro.new(node) if Macro.macro?(node)
+          end.group_by(&:visibility)
         end
 
-        def attr_within_visibility_scope?(node, visibility)
-          node.macro? &&
-            (attr_reader?(node) || attr_writer?(node)) &&
-            node_visibility(node) == visibility
+        def find_bisection(macros)
+          # Find which attributes are defined in both readers and writers so that they
+          # can be replaced with accessors.
+          readers, writers = macros.partition(&:reader?)
+          readers.flat_map(&:attr_names) & writers.flat_map(&:attr_names)
         end
 
-        def attr_reader?(send_node)
-          send_node.method?(:attr_reader) || send_node.method?(:attr)
+        def register_offense(attr)
+          add_offense(attr, message: format(MSG, name: attr.source))
         end
 
-        def attr_writer?(send_node)
-          send_node.method?(:attr_writer)
-        end
+        def correct_reader(corrector, macro, node, range)
+          attr_accessor = "attr_accessor #{macro.bisected_names.join(', ')}\n"
 
-        def check(macro, reader_names, writer_names)
-          macro.arguments.each do |arg_node|
-            name = arg_node.source
-
-            next unless (attr_reader?(macro) && writer_names.include?(name)) ||
-                        (attr_writer?(macro) && reader_names.include?(name))
-
-            add_offense(arg_node, message: format(MSG, name: name)) do |corrector|
-              macro = arg_node.parent
-
-              corrector.replace(macro, replacement(macro, arg_node))
-            end
-          end
-        end
-
-        def replacement(macro, node)
-          class_node = macro.each_ancestor(:class, :sclass, :module).first
-          reader_names, writer_names = accessor_names(class_node, node_visibility(macro))
-
-          rest_args = rest_args(macro.arguments, reader_names, writer_names)
-
-          if attr_reader?(macro)
-            attr_reader_replacement(macro, node, rest_args)
-          elsif rest_args.empty?
-            ''
+          if macro.all_bisected?
+            corrector.replace(range, "#{indent(node)}#{attr_accessor}")
           else
-            "#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
-          end
-        end
-
-        def rest_args(args, reader_names, writer_names)
-          args.reject do |arg|
-            name = arg.source
-            reader_names.include?(name) && writer_names.include?(name)
+            correction = "#{indent(node)}attr_reader #{macro.rest.join(', ')}"
+            corrector.insert_before(node, attr_accessor)
+            corrector.replace(node, correction)
           end
         end
 
-        def attr_reader_replacement(macro, node, rest_args)
-          if rest_args.empty?
-            "attr_accessor #{node.source}"
+        def correct_writer(corrector, macro, node, range)
+          if macro.all_bisected?
+            corrector.remove(range)
           else
-            "attr_accessor #{node.source}\n"\
-            "#{indent(macro)}#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+            correction = "attr_writer #{macro.rest.join(', ')}"
+            corrector.replace(node, correction)
           end
         end
       end

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

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
       #
+      # Methods that can be either procedural or functional and cannot be
+      # categorised from their usage alone is ignored.
+      # `lambda`, `proc`, and `it` are their defaults.
+      # Additional methods can be added to the `IgnoredMethods`.
+      #
       # @example EnforcedStyle: line_count_based (default)
       #   # bad - single line block
       #   items.each do |item| item / 5 end
@@ -132,9 +138,21 @@ module RuboCop
       #     puts foo
       #   end
       #
+      # @example IgnoredMethods: ['lambda', 'proc', 'it' ] (default)
+      #
+      #   # good
+      #   foo = lambda do |x|
+      #     puts "Hello, #{x}"
+      #   end
+      #
+      #   foo = lambda do |x|
+      #     x * 100
+      #   end
+      #
       class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        include RangeHelp
         extend AutoCorrector
 
         ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
@@ -174,7 +192,7 @@ module RuboCop
           if node.braces?
             replace_braces_with_do_end(corrector, node.loc)
           else
-            replace_do_end_with_braces(corrector, node.loc)
+            replace_do_end_with_braces(corrector, node)
           end
         end
 
@@ -231,10 +249,16 @@ module RuboCop
           corrector.insert_before(e, ' ') unless whitespace_before?(e)
           corrector.insert_after(b, ' ') unless whitespace_after?(b)
           corrector.replace(b, 'do')
+
+          if (comment = processed_source.comment_at_line(e.line))
+            move_comment_before_block(corrector, comment, loc.node, e)
+          end
+
           corrector.replace(e, 'end')
         end
 
-        def replace_do_end_with_braces(corrector, loc)
+        def replace_do_end_with_braces(corrector, node)
+          loc = node.loc
           b = loc.begin
           e = loc.end
 
@@ -242,6 +266,8 @@ module RuboCop
 
           corrector.replace(b, '{')
           corrector.replace(e, '}')
+
+          corrector.wrap(node.body, "begin\n", "\nend") if begin_required?(node)
         end
 
         def whitespace_before?(range)
@@ -252,6 +278,21 @@ module RuboCop
           /\s/.match?(range.source_buffer.source[range.begin_pos + length, 1])
         end
 
+        def move_comment_before_block(corrector, comment, block_node, closing_brace)
+          range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
+          comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
+          corrector.remove(range_with_surrounding_space(range: comment_range, side: :right))
+          corrector.insert_after(range, "\n")
+
+          corrector.insert_before(block_node, "#{comment.text}\n")
+        end
+
+        def end_of_chain(node)
+          return node unless node.chained?
+
+          end_of_chain(node.parent)
+        end
+
         def get_blocks(node, &block)
           case node.type
           when :block
@@ -376,7 +417,14 @@ module RuboCop
         def array_or_range?(node)
           node.array_type? || node.range_type?
         end
+
+        def begin_required?(block_node)
+          # If the block contains `rescue` or `ensure`, it needs to be wrapped in
+          # `begin`...`end` when changing `do-end` to `{}`.
+          block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
+        end
       end
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

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

@@ -5,9 +5,11 @@ module RuboCop
     module Style
       # This cop checks for uses of the case equality operator(===).
       #
+      # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
+      # the case equality operator is a constant.
+      #
       # @example
       #   # bad
-      #   Array === something
       #   (1..100) === 7
       #   /something/ === some_string
       #
@@ -16,18 +18,13 @@ module RuboCop
       #   (1..100).include?(7)
       #   /something/.match?(some_string)
       #
-      # @example AllowOnConstant
-      #   # Style/CaseEquality:
-      #   #   AllowOnConstant: true
-      #
+      # @example AllowOnConstant: false (default)
       #   # bad
-      #   (1..100) === 7
-      #   /something/ === some_string
+      #   Array === something
       #
+      # @example AllowOnConstant: true
       #   # good
       #   Array === something
-      #   (1..100).include?(7)
-      #   /something/.match?(some_string)
       #
       class CaseEquality < Base
         extend AutoCorrector
@@ -35,6 +32,7 @@ module RuboCop
         MSG = 'Avoid the use of the case equality operator `===`.'
         RESTRICT_ON_SEND = %i[===].freeze
 
+        # @!method case_equality?(node)
         def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
@@ -64,7 +62,7 @@ module RuboCop
             # The automatic correction from `a === b` to `a.match?(b)` needs to
             # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
             # This correction is expected to be supported by `Performance/Regexp` cop.
-            # See: https://github.com/rubocop-hq/rubocop-performance/issues/152
+            # See: https://github.com/rubocop/rubocop-performance/issues/152
             #
             # So here is noop.
           when :begin