rubocop 1.35.0 → 1.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6533c308e8ecd9193b09cd13fb1f967d1721cbfe4e4cb88bcb453861362b5152
-  data.tar.gz: a8ebb7e167336289eb9adf7e05cbf8bfe59ccc9669b9177b363a7d54b4d597fc
+  metadata.gz: 4bc2d4bd29fd7e81f4d7118fef9f55bcd2f086fd20ce383d85c2a1b7b26ea4e9
+  data.tar.gz: 9cb3cef8736b03dd0834b94fefe4415a301d78d842df184a1a1d290973376070
 SHA512:
-  metadata.gz: d49c12af4f602e15bf19903272b4ac0e834004f9eb07eecbca829a619559b6326dd95e2e9e10121763c73ff844968853e59dd89f84e9eded8d48bef0149cb379
-  data.tar.gz: 440d3e163691372ef95aa49847a58e611e669faf0d950f24b0135264d234c4bc4e35ef5c5a6d92394725cf3947295fd7b107dd48bfb7937df9a7fbac7ba70e90
+  metadata.gz: abeba580bae46458f6427c3d21c6532e95ff88e7d981d196f5013fee29c8f911146f229daa8e6f92d2f28bb14790edc46373a4366f9881700df18a7f5a1352fa
+  data.tar.gz: 4bee5fc42db940e95cd6e3fba83680e6d7fd573a8ed3b7c65136a48d5f3b67ba8d299ecdd30a422afb95961d84c9b0452e3d1b6c1952e0edee1cea97ca704952

data/README.md

@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.35', require: false
+gem 'rubocop', '~> 1.36', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -2794,6 +2794,7 @@ Naming/MethodParameterName:
   AllowNamesEndingInNumbers: true
   # Allowed names that will not register an offense
   AllowedNames:
+    - as
     - at
     - by
     - db
@@ -2948,6 +2949,7 @@ Style/AccessModifierDeclarations:
     - inline
     - group
   AllowModifiersOnSymbols: true
+  SafeAutoCorrect: false
 
 Style/AccessorGrouping:
   Description: 'Checks for grouping of accessors in `class` and `module` bodies.'
@@ -3186,6 +3188,15 @@ Style/CaseEquality:
   #   # good
   #   String === "string"
   AllowOnConstant: false
+  # If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
+  # the case equality operator is `self.class`.
+  #
+  #   # bad
+  #   some_class === object
+  #
+  #   # good
+  #   self.class === object
+  AllowOnSelfClass: false
 
 Style/CaseLikeIf:
   Description: 'Identifies places where `if-elsif` constructions can be replaced with `case-when`.'

data/lib/rubocop/config.rb

@@ -242,7 +242,7 @@ module RuboCop
       return nil unless loaded_path
 
       base_path = base_dir_for_path_parameters
-      ['gems.locked', 'Gemfile.lock'].each do |file_name|
+      ['Gemfile.lock', 'gems.locked'].each do |file_name|
         path = find_file_upwards(file_name, base_path)
         return path if path
       end

data/lib/rubocop/cop/generator/require_file_injector.rb

@@ -55,8 +55,8 @@ module RuboCop
           end
         end
 
-        def require_path_fragments(require_directove)
-          path = require_directove.match(REQUIRE_PATH)
+        def require_path_fragments(require_directive)
+          path = require_directive.match(REQUIRE_PATH)
 
           path ? path.captures.first.split('/') : []
         end

data/lib/rubocop/cop/internal_affairs/single_line_comparison.rb

@@ -29,20 +29,21 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<preferred>s`.'
-        RESTRICT_ON_SEND = %i[==].freeze
+        RESTRICT_ON_SEND = %i[== !=].freeze
 
         # @!method single_line_comparison(node)
         def_node_matcher :single_line_comparison, <<~PATTERN
           {
-            (send (send $_receiver {:line :first_line}) :== (send _receiver :last_line))
-            (send (send $_receiver :last_line) :== (send _receiver {:line :first_line}))
+            (send (send $_receiver {:line :first_line}) {:== :!=} (send _receiver :last_line))
+            (send (send $_receiver :last_line) {:== :!=} (send _receiver {:line :first_line}))
           }
         PATTERN
 
         def on_send(node)
           return unless (receiver = single_line_comparison(node))
 
-          preferred = "#{extract_receiver(receiver)}.single_line?"
+          bang = node.method?(:!=) ? '!' : ''
+          preferred = "#{bang}#{extract_receiver(receiver)}.single_line?"
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
             corrector.replace(node, preferred)

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

@@ -22,23 +22,24 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
-      #   variable = lambda do |i|
-      #     i
+      #   foo.bar
+      #     .each do
+      #       baz
       #   end
       #
       # @example EnforcedStyleAlignWith: start_of_block
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
@@ -51,16 +52,17 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
       #   foo.bar
       #     .each do
-      #        baz
+      #       baz
       #   end
+      #
       class BlockAlignment < Base
         include ConfigurableEnforcedStyle
         include RangeHelp

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

@@ -22,20 +22,20 @@ module RuboCop
       #   # all platforms.
       #
       #   # bad
-      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #   puts 'Hello' # Return character is CR+LF on all platforms.
       #
       #   # good
-      #   puts 'Hello' # Return character is LF on all platfoms.
+      #   puts 'Hello' # Return character is LF on all platforms.
       #
       # @example EnforcedStyle: crlf
       #   # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
       #   # enforced on all platforms.
       #
       #   # bad
-      #   puts 'Hello' # Return character is LF on all platfoms.
+      #   puts 'Hello' # Return character is LF on all platforms.
       #
       #   # good
-      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #   puts 'Hello' # Return character is CR+LF on all platforms.
       #
       class EndOfLine < Base
         include ConfigurableEnforcedStyle

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

@@ -143,7 +143,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'the position of the opening bracket'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'the first position after the preceding left parenthesis'
           when :parent_hash_key
             'the parent hash key'
@@ -164,7 +164,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'Indent the right bracket the same as the left bracket.'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'Indent the right bracket the same as the first position ' \
             'after the preceding left parenthesis.'
           when :parent_hash_key

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

@@ -192,7 +192,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'the position of the opening brace'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'the first position after the preceding left parenthesis'
           when :parent_hash_key
             'the parent hash key'
@@ -213,7 +213,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'Indent the right brace the same as the left brace.'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'Indent the right brace the same as the first position ' \
             'after the preceding left parenthesis.'
           when :parent_hash_key

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

@@ -148,7 +148,9 @@ module RuboCop
             check_indentation(in_pattern_node.loc.keyword, in_pattern_node.body)
           end
 
-          check_indentation(case_match.in_pattern_branches.last.loc.keyword, case_match.else_branch)
+          else_branch = case_match.else_branch&.empty_else_type? ? nil : case_match.else_branch
+
+          check_indentation(case_match.in_pattern_branches.last.loc.keyword, else_branch)
         end
 
         def on_if(node, base = node)

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

@@ -101,7 +101,7 @@ module RuboCop
           !comment_within?(node) &&
             node.each_descendant(:if, :case, :kwbegin, :def).none? &&
             node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
-            node.each_descendant(:begin).none? { |b| b.first_line != b.last_line }
+            node.each_descendant(:begin).none? { |b| !b.single_line? }
         end
 
         def convertible_block?(node)

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

@@ -131,7 +131,7 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin if node.block_type? # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.begin, node.loc.end, node.single_line?)
+          check_right_brace(node, inner, node.loc.begin, node.loc.end, node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
@@ -142,14 +142,15 @@ module RuboCop
           end
         end
 
-        def check_right_brace(inner, left_brace, right_brace, single_line)
+        def check_right_brace(node, inner, left_brace, right_brace, single_line)
           if single_line && /\S$/.match?(inner)
             no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
           else
+            column = node.loc.expression.column
             return if multiline_block?(left_brace, right_brace) &&
-                      aligned_braces?(left_brace, right_brace)
+                      aligned_braces?(inner, right_brace, column)
 
-            space_inside_right_brace(right_brace)
+            space_inside_right_brace(inner, right_brace, column)
           end
         end
 
@@ -157,8 +158,12 @@ module RuboCop
           left_brace.first_line != right_brace.first_line
         end
 
-        def aligned_braces?(left_brace, right_brace)
-          left_brace.first_line == right_brace.last_column
+        def aligned_braces?(inner, right_brace, column)
+          column == right_brace.column || column == inner_last_space_count(inner)
+        end
+
+        def inner_last_space_count(inner)
+          inner.split("\n").last.count(' ')
         end
 
         def no_space_inside_left_brace(left_brace, args_delimiter)
@@ -197,10 +202,21 @@ module RuboCop
           args_delimiter&.is?('|')
         end
 
-        def space_inside_right_brace(right_brace)
+        def space_inside_right_brace(inner, right_brace, column)
           brace_with_space = range_with_surrounding_space(right_brace, side: :left)
-          space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
-                'Space inside } detected.')
+          begin_pos = brace_with_space.begin_pos
+          end_pos = brace_with_space.end_pos - 1
+
+          if brace_with_space.source.match?(/\R/)
+            begin_pos = end_pos - (right_brace.column - column)
+          end
+
+          if inner.end_with?(']')
+            end_pos -= 1
+            begin_pos = end_pos - (inner_last_space_count(inner) - column)
+          end
+
+          space(begin_pos, end_pos, 'Space inside } detected.')
         end
 
         def no_space(begin_pos, end_pos, msg)

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

@@ -81,7 +81,7 @@ module RuboCop
         def allowed_method_pattern?(node)
           node.assignment? || node.operator_method? || node.method?(:[]) ||
             allowed_method?(node.last_argument.method_name) ||
-            matches_allowed_pattern?(node.last_argument.method_name)
+            matches_allowed_pattern?(node.last_argument.send_node.source)
         end
 
         def message(send_node)

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

@@ -66,7 +66,7 @@ module RuboCop
           private
 
           def delimiter
-            CLASS_METHOD_DELIMETER
+            CLASS_METHOD_DELIMITER
           end
         end
 
@@ -89,7 +89,7 @@ module RuboCop
           private
 
           def delimiter
-            instance_method? ? INSTANCE_METHOD_DELIMETER : CLASS_METHOD_DELIMETER
+            instance_method? ? INSTANCE_METHOD_DELIMITER : CLASS_METHOD_DELIMITER
           end
 
           def instance_method?
@@ -126,8 +126,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
 
-        CLASS_METHOD_DELIMETER = '.'
-        INSTANCE_METHOD_DELIMETER = '#'
+        CLASS_METHOD_DELIMITER = '.'
+        INSTANCE_METHOD_DELIMITER = '#'
 
         def on_send(node)
           check(node) do |deprecated|

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for duplicate `require`s and `require_relative`s.
+      # Checks for duplicate ``require``s and ``require_relative``s.
       #
       # @safety
       #   This cop's autocorrection is unsafe because it may break the dependency order

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

@@ -96,7 +96,7 @@ module RuboCop
         end
 
         def correct_other_branches(corrector, node)
-          return unless (node.if? || node.unless?) && node.else_branch
+          return unless require_other_branches_correction?(node)
 
           if node.else_branch.if_type?
             # Replace an orphaned `elsif` with `if`
@@ -107,13 +107,43 @@ module RuboCop
           end
         end
 
+        def require_other_branches_correction?(node)
+          return false unless node.if_type? && node.else_branch
+          return false if !empty_if_branch?(node) && node.elsif?
+
+          !empty_else_branch?(node)
+        end
+
+        def empty_if_branch?(node)
+          return false unless (parent = node.parent)
+          return true unless parent.if_type?
+          return true unless (if_branch = parent.if_branch)
+
+          if_branch.if_type? && !if_branch.body
+        end
+
+        def empty_else_branch?(node)
+          node.else_branch.if_type? && !node.else_branch.body
+        end
+
+        # rubocop:disable Metrics/AbcSize
         def branch_range(node)
           if node.loc.else
             node.source_range.with(end_pos: node.loc.else.begin_pos - 1)
+          elsif all_branches_body_missing?(node)
+            if_node = node.ancestors.detect(&:if?)
+            node.source_range.with(end_pos: if_node.loc.end.end_pos)
           else
             node.source_range
           end
         end
+        # rubocop:enable Metrics/AbcSize
+
+        def all_branches_body_missing?(node)
+          return false unless node.parent&.if_type?
+
+          node.parent.branches.compact.empty?
+        end
 
         def deletion_range(range)
           # Collect a range between the start of the `if` node and the next relevant node,

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

@@ -58,6 +58,7 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
+        # rubocop:disable Metrics/MethodLength
         def autocorrected_value(node)
           case node.type
           when :int
@@ -70,10 +71,13 @@ module RuboCop
             autocorrected_value_for_symbol(node)
           when :array
             autocorrected_value_for_array(node)
+          when :nil
+            ''
           else
             node.source.gsub('"', '\"')
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')

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

@@ -99,19 +99,19 @@ module RuboCop
         end
 
         def register_offense(node, exist_node)
-          unless force_method?(node)
-            add_offense(node,
-                        message: format(MSG_CHANGE_FORCE_METHOD,
-                                        method_name: replacement_method(node)))
-          end
+          add_offense(node, message: message_change_force_method(node)) unless force_method?(node)
 
           range = range_between(node.parent.loc.keyword.begin_pos,
                                 exist_node.loc.expression.end_pos)
           add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
-            autocorrect(corrector, node, range)
+            autocorrect(corrector, node, range) unless node.parent.elsif?
           end
         end
 
+        def message_change_force_method(node)
+          format(MSG_CHANGE_FORCE_METHOD, method_name: replacement_method(node))
+        end
+
         def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
           format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)

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

@@ -7,6 +7,11 @@ module RuboCop
       # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
       # are checked by default. These are customizable with `AllowedMethods` option.
       #
+      # The `AllowedMethods` option specifies nil-safe methods,
+      # in other words, it is a method that is allowed to skip safe navigation.
+      # Note that the `AllowedMethod` option is not an option that specifies methods
+      # for which to suppress (allow) this cop's check.
+      #
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
@@ -35,12 +40,13 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
-      # @example AllowedMethods: [foo?]
+      # @example AllowedMethods: [nil_safe_method]
       #   # bad
-      #   do_something if attrs&.foo?(:[])
+      #   do_something if attrs&.nil_safe_method(:[])
       #
       #   # good
-      #   do_something if attrs&.bar?(:[])
+      #   do_something if attrs.nil_safe_method(:[])
+      #   do_something if attrs&.not_nil_safe_method(:[])
       #
       class RedundantSafeNavigation < Base
         include AllowedMethods

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

@@ -12,7 +12,7 @@ module RuboCop
       # same `rescue` statement. In both cases, the more specific rescue is
       # unnecessary because it is covered by rescuing the less specific
       # exception. (ie. `rescue Exception, StandardError` has the same behavior
-      # whether `StandardError` is included or not, because all `StandardError`s
+      # whether `StandardError` is included or not, because all ``StandardError``s
       # are rescued by `rescue Exception`).
       #
       # @example

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

@@ -64,14 +64,26 @@ module RuboCop
         end
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
-          variable_node = variable.scope.node.parent
+          variable_node = variable_node(variable)
           return false unless variable_node.conditional?
 
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
           return true unless outer_local_variable_node
 
-          outer_local_variable_node.conditional? && variable_node == outer_local_variable_node
+          outer_local_variable_node.conditional? &&
+            (variable_node == outer_local_variable_node ||
+              variable_node == outer_local_variable_node.else_branch)
+        end
+
+        def variable_node(variable)
+          parent_node = variable.scope.node.parent
+
+          if parent_node.when_type?
+            parent_node.parent
+          else
+            parent_node
+          end
         end
 
         def find_conditional_node_from_ascendant(node)

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

@@ -9,7 +9,7 @@ module RuboCop
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
-      # NOTE: Block methods that are used with `Enumerable`s are considered to be loops.
+      # NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
       #
       # `AllowedPatterns` can be used to match against the block receiver in order to allow
       # code that would otherwise be registered as an offense (eg. `times` used not in an

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

@@ -31,8 +31,8 @@ module RuboCop
       #   # bad
       #   class Foo
       #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
+      #     # singleton class are not affected by the private modifier)
+      #     private
       #
       #     def self.method3
       #     end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Looks for `ruby2_keywords` calls for methods that do not need it.
       #
       # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example

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

@@ -17,16 +17,21 @@ module RuboCop
 
       # @api public
       def allowed_methods
-        deprecated_values = cop_config_deprecated_values
-        if deprecated_values.any?(Regexp)
-          cop_config.fetch('AllowedMethods', [])
+        if cop_config_deprecated_values.any?(Regexp)
+          cop_config_allowed_methods
         else
-          Array(cop_config['AllowedMethods']).concat(deprecated_values)
+          cop_config_allowed_methods + cop_config_deprecated_values
         end
       end
 
+      def cop_config_allowed_methods
+        @cop_config_allowed_methods ||= Array(cop_config.fetch('AllowedMethods', []))
+      end
+
       def cop_config_deprecated_values
-        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
+        @cop_config_deprecated_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
     # @deprecated IgnoredMethods class has been replaced with AllowedMethods.

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

@@ -30,15 +30,23 @@ module RuboCop
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two
         # arrays together.
-        patterns = Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
-        deprecated_values = cop_config_deprecated_methods_values
-        return patterns unless deprecated_values.any?(Regexp)
+        if cop_config_deprecated_methods_values.any?(Regexp)
+          cop_config_patterns_values + cop_config_deprecated_methods_values
+        else
+          cop_config_patterns_values
+        end
+      end
 
-        Array(patterns.concat(deprecated_values))
+      def cop_config_patterns_values
+        @cop_config_patterns_values ||=
+          Array(cop_config.fetch('AllowedPatterns', [])) +
+          Array(cop_config.fetch('IgnoredPatterns', []))
       end
 
       def cop_config_deprecated_methods_values
-        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
+        @cop_config_deprecated_methods_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
 

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

@@ -220,7 +220,7 @@ module RuboCop
       def already_on_multiple_lines?(node)
         return node.first_line != node.arguments.last.last_line if node.def_type?
 
-        node.first_line != node.last_line
+        !node.single_line?
       end
     end
   end