rubocop 1.36.0 → 1.39.0

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

@@ -46,10 +46,13 @@ module RuboCop
       #   # bad
       #   foo = { }
       #   bar = {    }
+      #   baz = {
+      #   }
       #
       #   # good
       #   foo = {}
       #   bar = {}
+      #   baz = {}
       #
       # @example EnforcedStyleForEmptyBraces: space
       #   # The `space` EnforcedStyleForEmptyBraces style enforces that
@@ -60,8 +63,9 @@ module RuboCop
       #
       #   # good
       #   foo = { }
-      #   foo = {  }
-      #   foo = {     }
+      #   foo = {    }
+      #   foo = {
+      #   }
       #
       class SpaceInsideHashLiteralBraces < Base
         include SurroundingSpace
@@ -77,6 +81,7 @@ module RuboCop
 
           check(tokens[0], tokens[1])
           check(tokens[-2], tokens[-1]) if tokens.size > 2
+          check_whitespace_only_hash(node) if enforce_no_space_style_for_empty_braces?
         end
 
         private
@@ -103,7 +108,7 @@ module RuboCop
           if is_same_braces && style == :compact
             false
           elsif is_empty_braces
-            cop_config['EnforcedStyleForEmptyBraces'] != 'no_space'
+            !enforce_no_space_style_for_empty_braces?
           else
             style != :no_space
           end
@@ -175,6 +180,28 @@ module RuboCop
 
           range_between(begin_pos, range.end_pos - 1)
         end
+
+        def check_whitespace_only_hash(node)
+          range = range_inside_hash(node)
+          return unless range.source.match?(/\A\s+\z/m)
+
+          add_offense(
+            range,
+            message: format(MSG, problem: 'empty hash literal braces detected')
+          ) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def range_inside_hash(node)
+          return node.source_range if node.location.begin.nil?
+
+          range_between(node.location.begin.end_pos, node.location.end.begin_pos)
+        end
+
+        def enforce_no_space_style_for_empty_braces?
+          cop_config['EnforcedStyleForEmptyBraces'] == 'no_space'
+        end
       end
     end
   end

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

@@ -8,14 +8,31 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #   %i( foo bar baz )
+      #
       #   # good
       #   %i(foo bar baz)
       #
       #   # bad
       #   %w( foo bar baz )
       #
+      #   # good
+      #   %w(foo bar baz)
+      #
       #   # bad
       #   %x(  ls -l )
+      #
+      #   # good
+      #   %x(ls -l)
+      #
+      #   # bad
+      #   %w( )
+      #   %w(
+      #   )
+      #
+      #   # good
+      #   %w()
       class SpaceInsidePercentLiteralDelimiters < Base
         include MatchRange
         include PercentLiteral
@@ -34,11 +51,21 @@ module RuboCop
         end
 
         def on_percent_literal(node)
+          add_offenses_for_blank_spaces(node)
           add_offenses_for_unnecessary_spaces(node)
         end
 
         private
 
+        def add_offenses_for_blank_spaces(node)
+          range = body_range(node)
+          return if range.source.empty? || !range.source.strip.empty?
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
         def add_offenses_for_unnecessary_spaces(node)
           return unless node.single_line?
 
@@ -54,6 +81,13 @@ module RuboCop
             each_match_range(contents_range(node), regex, &blk)
           end
         end
+
+        def body_range(node)
+          node.location.expression.with(
+            begin_pos: node.location.begin.end_pos,
+            end_pos: node.location.end.begin_pos
+          )
+        end
       end
     end
   end

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

@@ -38,6 +38,8 @@ module RuboCop
       #   # bad
       #   foo[ ]
       #   foo[     ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[]
@@ -49,6 +51,8 @@ module RuboCop
       #   # bad
       #   foo[]
       #   foo[    ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[ ]
@@ -64,8 +68,6 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return if node.multiline?
-
           tokens = processed_source.tokens_within(node)
           left_token = left_ref_bracket(node, tokens)
           return unless left_token
@@ -76,6 +78,8 @@ module RuboCop
             return empty_offenses(node, left_token, right_token, EMPTY_MSG)
           end
 
+          return if node.multiline?
+
           if style == :no_space
             no_space_offenses(node, left_token, right_token, MSG)
           else

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

@@ -45,7 +45,7 @@ module RuboCop
       #   # bad
       #   expect { do_something }.to change { object.attribute }
       #
-      # @example AllowedPatterns: [/change/]
+      # @example AllowedPatterns: ['change']
       #
       #   # good
       #   expect { do_something }.to change { object.attribute }

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for duplicated magic comments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # encoding: ascii
+      #   # encoding: ascii
+      #
+      #   # good
+      #
+      #   # encoding: ascii
+      #
+      #   # bad
+      #
+      #   # frozen_string_literal: true
+      #   # frozen_string_literal: true
+      #
+      #   # good
+      #
+      #   # frozen_string_literal: true
+      #
+      class DuplicateMagicComment < Base
+        include FrozenStringLiteral
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Duplicate magic comment detected.'
+
+        def on_new_investigation
+          return if processed_source.buffer.source.empty?
+
+          magic_comment_lines.each_value do |comment_lines|
+            next if comment_lines.count <= 1
+
+            comment_lines[1..].each do |comment_line|
+              range = processed_source.buffer.line_range(comment_line + 1)
+
+              register_offense(range)
+            end
+          end
+        end
+
+        private
+
+        def magic_comment_lines
+          comment_lines = { encoding_magic_comments: [], frozen_string_literal_magic_comments: [] }
+
+          leading_magic_comments.each.with_index do |magic_comment, index|
+            if magic_comment.encoding_specified?
+              comment_lines[:encoding_magic_comments] << index
+            elsif magic_comment.frozen_string_literal_specified?
+              comment_lines[:frozen_string_literal_magic_comments] << index
+            end
+          end
+
+          comment_lines
+        end
+
+        def register_offense(range)
+          add_offense(range) do |corrector|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,8 +51,8 @@ module RuboCop
       #   alias bar foo
       class DuplicateMethods < Base
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-
         RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
+        DEF_TYPES = %i[def defs].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -127,13 +127,13 @@ module RuboCop
           found_method(node, "#{enclosing}.#{name}")
         end
 
-        def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
+        def message_for_dup(node, method_name, key)
+          format(MSG, method: method_name, defined: source_location(@definitions[key]),
                       current: source_location(node))
         end
 
         def found_instance_method(node, name)
-          return unless (scope = node.parent_module_name)
+          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
 
           # Humanize the scope
           scope = scope.sub(
@@ -145,19 +145,38 @@ module RuboCop
           found_method(node, "#{scope}#{name}")
         end
 
+        def found_sclass_method(node, name)
+          singleton_ancestor = node.each_ancestor.find(&:sclass_type?)
+          return unless singleton_ancestor
+
+          singleton_receiver_node = singleton_ancestor.children[0]
+          return unless singleton_receiver_node.send_type?
+
+          found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
+        end
+
         def found_method(node, method_name)
-          if @definitions.key?(method_name)
-            loc = case node.type
-                  when :def, :defs
+          key = method_key(node, method_name)
+
+          if @definitions.key?(key)
+            loc = if DEF_TYPES.include?(node.type)
                     node.loc.keyword.join(node.loc.name)
                   else
                     node.loc.expression
                   end
-            message = message_for_dup(node, method_name)
+            message = message_for_dup(node, method_name, key)
 
             add_offense(loc, message: message)
           else
-            @definitions[method_name] = node
+            @definitions[key] = node
+          end
+        end
+
+        def method_key(node, method_name)
+          if (ancestor_def = node.each_ancestor(*DEF_TYPES).first)
+            "#{ancestor_def.method_name}.#{method_name}"
+          else
+            method_name
           end
         end
 

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

@@ -32,26 +32,40 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def each_repeated_character_class_element_loc(node)
           node.parsed_tree&.each_expression do |expr|
-            next if expr.type != :set || expr.token == :intersection
+            next if skip_expression?(expr)
 
             seen = Set.new
+            enum = expr.expressions.to_enum
+            expression_count = expr.expressions.count
 
-            expr.expressions.each do |child|
-              next if within_interpolation?(node, child)
+            expression_count.times do |current_number|
+              current_child = enum.next
+              next if within_interpolation?(node, current_child)
 
-              child_source = child.to_s
+              current_child_source = current_child.to_s
+              next_child = enum.peek if current_number + 1 < expression_count
 
-              yield child.expression if seen.include?(child_source)
+              if seen.include?(current_child_source)
+                next if start_with_escaped_zero_number?(current_child_source, next_child.to_s)
 
-              seen << child_source
+                yield current_child.expression
+              end
+
+              seen << current_child_source
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 
+        def skip_expression?(expr)
+          expr.type != :set || expr.token == :intersection
+        end
+
         # Since we blank interpolations with a space for every char of the interpolation, we would
         # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
         # that are within an interpolation.
@@ -61,6 +75,11 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
+        def start_with_escaped_zero_number?(current_child, next_child)
+          # Represents escaped code from `"\00"` (`"\u0000"`) to `"\07"` (`"\a"`).
+          current_child == '\\0' && next_child.match?(/[0-7]/)
+        end
+
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -85,7 +85,9 @@ module RuboCop
         private
 
         def body_or_allowed_comment_lines?(node)
-          node.body || (cop_config['AllowComments'] && comment_lines?(node))
+          return true if node.body
+
+          cop_config['AllowComments'] && processed_source.contains_comment?(node.source_range)
         end
       end
     end

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

@@ -92,13 +92,17 @@ module RuboCop
         end
 
         def remove_empty_branch(corrector, node)
-          corrector.remove(deletion_range(branch_range(node)))
+          if empty_if_branch?(node) && else_branch?(node)
+            corrector.remove(branch_range(node))
+          else
+            corrector.remove(deletion_range(branch_range(node)))
+          end
         end
 
         def correct_other_branches(corrector, node)
           return unless require_other_branches_correction?(node)
 
-          if node.else_branch.if_type?
+          if node.else_branch&.if_type?
             # Replace an orphaned `elsif` with `if`
             corrector.replace(node.else_branch.loc.keyword, 'if')
           else
@@ -108,10 +112,10 @@ module RuboCop
         end
 
         def require_other_branches_correction?(node)
-          return false unless node.if_type? && node.else_branch
+          return false unless node.if_type? && node.else?
           return false if !empty_if_branch?(node) && node.elsif?
 
-          !empty_else_branch?(node)
+          !empty_elsif_branch?(node)
         end
 
         def empty_if_branch?(node)
@@ -122,14 +126,22 @@ module RuboCop
           if_branch.if_type? && !if_branch.body
         end
 
-        def empty_else_branch?(node)
-          node.else_branch.if_type? && !node.else_branch.body
+        def empty_elsif_branch?(node)
+          return false unless (else_branch = node.else_branch)
+
+          else_branch.if_type? && !else_branch.body
+        end
+
+        def else_branch?(node)
+          node.else_branch && !node.else_branch.if_type?
         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)
+          if empty_if_branch?(node) && else_branch?(node)
+            node.source_range.with(end_pos: node.loc.else.begin_pos)
+          elsif node.loc.else
+            node.source_range.with(end_pos: node.condition.loc.expression.end_pos)
           elsif all_branches_body_missing?(node)
             if_node = node.ancestors.detect(&:if?)
             node.source_range.with(end_pos: if_node.loc.end.end_pos)

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

@@ -50,9 +50,7 @@ module RuboCop
 
         def on_new_investigation
           each_missing_enable do |cop, line_range|
-            # This has to remain a strict inequality to handle
-            # the case when max_range is Float::INFINITY
-            next if line_range.max - line_range.min < max_range + 2
+            next if acceptable_range?(cop, line_range)
 
             range = source_range(processed_source.buffer, line_range.min, (0..0))
             comment = processed_source.comment_at_line(line_range.begin)
@@ -69,6 +67,23 @@ module RuboCop
           end
         end
 
+        def acceptable_range?(cop, line_range)
+          # This has to remain a strict inequality to handle
+          # the case when max_range is Float::INFINITY
+          return true if line_range.max - line_range.min < max_range + 2
+          # This cop is disabled in the config, it is not expected to be re-enabled
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          if cop_class &&
+             !processed_source.registry.enabled?(cop_class, config) &&
+             line_range.max == Float::INFINITY
+            return true
+          end
+
+          false
+        end
+
         def max_range
           @max_range ||= cop_config['MaximumRangeSize']
         end

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

@@ -30,6 +30,9 @@ module RuboCop
       #
       #   # good
       #
+      #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
+      #   # `module_exec` blocks are allowed by default.
+      #
       #   def foo
       #     self.class.class_eval do
       #       def bar
@@ -54,7 +57,47 @@ module RuboCop
       #       end
       #     end
       #   end
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['has_many']
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['baz']
+      #   # good
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
       class NestedMethodDefinition < Base
+        include AllowedMethods
+        include AllowedPattern
+
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
@@ -77,7 +120,13 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child)
+            class_or_module_or_struct_new_call?(child) || allowed_method_name?(child)
+        end
+
+        def allowed_method_name?(node)
+          name = node.method_name
+
+          allowed_method?(name) || matches_allowed_pattern?(name)
         end
 
         # @!method eval_call?(node)

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

@@ -61,7 +61,7 @@ module RuboCop
       #   # bad
       #   10.minutes.to_i
       #
-      # @example AllowedPatterns: [/min*/]
+      # @example AllowedPatterns: ['min*']
       #
       #   # good
       #   10.minutes.to_i

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

@@ -7,6 +7,9 @@ module RuboCop
       # Checks the proper ordering of magic comments and whether
       # a magic comment is not placed before a shebang.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because file encoding may change.
+      #
       # @example
       #   # bad
       #
@@ -61,7 +64,7 @@ module RuboCop
         def magic_comment_lines
           lines = [nil, nil]
 
-          magic_comments.each.with_index do |comment, index|
+          leading_magic_comments.each.with_index do |comment, index|
             if comment.encoding_specified?
               lines[0] = index
             elsif comment.frozen_string_literal_specified?
@@ -73,10 +76,6 @@ module RuboCop
 
           lines
         end
-
-        def magic_comments
-          leading_comment_lines.map { |line| MagicComment.parse(line) }
-        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cops looks for references of Regexp captures that are out of range
+      # Looks for references of Regexp captures that are out of range
       # and thus always returns nil.
       #
       # @safety

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

@@ -113,6 +113,7 @@ module RuboCop
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if ignore_offense?(line_range)
+            next if expected_final_disable?(cop, line_range)
 
             comment = processed_source.comment_at_line(line_range.begin)
             redundant = if all_disabled?(comment)
@@ -179,11 +180,21 @@ module RuboCop
         end
 
         def ignore_offense?(line_range)
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def expected_final_disable?(cop, line_range)
+          # A cop which is disabled in the config is being re-disabled until end of file
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          cop_class &&
+            !processed_source.registry.enabled?(cop_class, config) &&
+            line_range.max == Float::INFINITY
+        end
+
         def department_disabled?(cop, comment)
           directive = DirectiveComment.new(comment)
           directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)
@@ -209,7 +220,12 @@ module RuboCop
 
           add_offense(location, message: message(cop_names)) do |corrector|
             range = comment_range_with_surrounding_space(location, comment.loc.expression)
-            corrector.remove(range)
+
+            if leave_free_comment?(comment, range)
+              corrector.replace(range, ' # ')
+            else
+              corrector.remove(range)
+            end
           end
         end
 
@@ -227,6 +243,12 @@ module RuboCop
           end
         end
 
+        def leave_free_comment?(comment, range)
+          free_comment = comment.text.gsub(range.source.strip, '')
+
+          !free_comment.empty? && !free_comment.start_with?('#')
+        end
+
         def cop_range(comment, cop)
           cop = remove_department_marker(cop)
           matching_range(comment.loc.expression, cop) ||