rubocop 1.12.1 → 1.16.1

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

@@ -25,9 +25,7 @@ module RuboCop
         def on_interpolation(begin_node)
           return unless begin_node.children.empty?
 
-          add_offense(begin_node) do |corrector|
-            corrector.remove(begin_node.loc.expression)
-          end
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node.loc.expression) }
         end
       end
     end

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

@@ -51,9 +51,7 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          node.body&.each_node(:return) do |return_node|
-            add_offense(return_node)
-          end
+          node.body&.each_node(:return) { |return_node| add_offense(return_node) }
         end
       end
     end

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

@@ -112,16 +112,13 @@ module RuboCop
           kwargs = build_kwargs(node)
           overridden_kwargs = override_by_legacy_args(kwargs, node)
 
-          good_arguments = [
-            str_arg, overridden_kwargs
-          ].flatten.compact.join(', ')
+          good_arguments = [str_arg, overridden_kwargs].flatten.compact.join(', ')
 
           corrector.replace(arguments_range(node), good_arguments)
         end
 
         def correct_arguments?(arguments)
-          arguments.size == 1 ||
-            arguments.size == 2 && arguments[1].hash_type?
+          arguments.size == 1 || arguments.size == 2 && arguments[1].hash_type?
         end
 
         def build_kwargs(node)
@@ -157,8 +154,7 @@ module RuboCop
         def arguments_range(node)
           arguments = node.arguments
 
-          range_between(arguments.first.source_range.begin_pos,
-                        arguments.last.source_range.end_pos)
+          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
         end
       end
     end

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

@@ -24,8 +24,7 @@ module RuboCop
         def on_float(node)
           value, = *node
 
-          return unless value.infinite? ||
-                        value.zero? && /[1-9]/.match?(node.source)
+          return unless value.infinite? || value.zero? && /[1-9]/.match?(node.source)
 
           add_offense(node)
         end

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

@@ -140,8 +140,7 @@ module RuboCop
         end
 
         def format_method?(name, node)
-          return false if node.const_receiver? &&
-                          !node.receiver.loc.name.is?(KERNEL)
+          return false if node.const_receiver? && !node.receiver.loc.name.is?(KERNEL)
           return false unless node.method?(name)
 
           node.arguments.size > 1 && node.first_argument.str_type?
@@ -174,11 +173,9 @@ module RuboCop
           receiver = node.receiver
 
           percent = node.method?(:%) &&
-                    (STRING_TYPES.include?(receiver.type) ||
-                     node.first_argument.array_type?)
+                    (STRING_TYPES.include?(receiver.type) || node.first_argument.array_type?)
 
-          return false if percent && STRING_TYPES.include?(receiver.type) &&
-                          heredoc?(node)
+          return false if percent && STRING_TYPES.include?(receiver.type) && heredoc?(node)
 
           percent
         end

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

@@ -34,8 +34,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Put a method call with a HEREDOC receiver on the ' \
-        'same line as the HEREDOC opening.'
+        MSG = 'Put a method call with a HEREDOC receiver on the same line as the HEREDOC opening.'
 
         def on_send(node)
           heredoc = heredoc_node_descendent_receiver(node)

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

@@ -73,8 +73,7 @@ module RuboCop
         end
 
         def string_literal?(node)
-          node.str_type? ||
-            (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
+          node.str_type? || (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
         end
 
         def string_literals?(node1, node2)

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

@@ -48,10 +48,8 @@ module RuboCop
       class IneffectiveAccessModifier < Base
         MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
               'methods %<modifier>s. Use %<alternative>s instead.'
-        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
-                              '`class << self` block'
-        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
-                                'block'
+        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a `class << self` block'
+        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` block'
 
         # @!method private_class_methods(node)
         def_node_search :private_class_methods, <<~PATTERN
@@ -74,9 +72,7 @@ module RuboCop
         end
 
         def private_class_method_names(node)
-          private_class_methods(node).to_a.flatten
-                                     .select(&:basic_literal?)
-                                     .map(&:value)
+          private_class_methods(node).to_a.flatten.select(&:basic_literal?).map(&:value)
         end
 
         def format_message(modifier)

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

@@ -66,8 +66,7 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          return unless node.parent_class &&
-                        illegal_class_name?(node.parent_class)
+          return unless node.parent_class && illegal_class_name?(node.parent_class)
 
           message = message(node.parent_class)
 

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

@@ -23,23 +23,16 @@ module RuboCop
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          return unless node
-          return if string_or_regex?(node.parent)
+          return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
           return unless node.loc.begin && node.loc.end
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private
 
-        def string_or_regex?(node)
-          node&.dstr_type? || node&.regexp_type?
-        end
-
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']
@@ -52,8 +45,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          node.loc.is_a?(Parser::Source::Map::Heredoc) ||
-            (node.parent && heredoc?(node.parent))
+          node.loc.is_a?(Parser::Source::Map::Heredoc) || (node.parent && heredoc?(node.parent))
         end
       end
     end

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

@@ -34,8 +34,7 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
-          return if in_array_percent_literal?(begin_node) &&
-                    /\s/.match?(expanded_value)
+          return if in_array_percent_literal?(begin_node) && /\s/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration
@@ -56,8 +55,7 @@ module RuboCop
 
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) ||
-            node.source_range.is?('__LINE__')
+          (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
         def autocorrected_value(node)
@@ -101,8 +99,7 @@ module RuboCop
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||
-            (COMPOSITE.include?(node.type) &&
-              node.children.all? { |child| prints_as_self?(child) })
+            (COMPOSITE.include?(node.type) && node.children.all? { |child| prints_as_self?(child) })
         end
 
         def space_literal?(node)

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

@@ -49,8 +49,7 @@ module RuboCop
       class Loop < Base
         extend AutoCorrector
 
-        MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'
+        MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
 
         def on_while_post(node)
           register_offense(node)

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

@@ -45,10 +45,8 @@ module RuboCop
       class MissingCopEnableDirective < Base
         include RangeHelp
 
-        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
-              'disabling it.'
-        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
-                    'disabling it.'
+        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after disabling it.'
 
         # rubocop:disable Metrics/AbcSize
         def on_new_investigation
@@ -59,9 +57,7 @@ module RuboCop
               # the case when max_range is Float::INFINITY
               next if line_range.max - line_range.min < max_range + 2
 
-              range = source_range(processed_source.buffer,
-                                   line_range.min,
-                                   (0..0))
+              range = source_range(processed_source.buffer, line_range.min, (0..0))
 
               add_offense(range, message: message(max_range: max_range, cop: cop))
             end

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

@@ -53,8 +53,7 @@ module RuboCop
                                          singleton_method_added singleton_method_removed
                                          singleton_method_undefined].freeze
 
-        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS +
-                     METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)

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

@@ -21,8 +21,7 @@ module RuboCop
       #   /(FOO)(BAR)/
       #
       class MixedRegexpCaptureTypes < Base
-        MSG = 'Do not mix named captures and numbered captures ' \
-              'in a Regexp literal.'
+        MSG = 'Do not mix named captures and numbered captures in a Regexp literal.'
 
         def on_regexp(node)
           return if node.interpolation?

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

@@ -55,8 +55,7 @@ module RuboCop
       #     end
       #   end
       class NestedMethodDefinition < Base
-        MSG = 'Method definitions must not be nested. ' \
-              'Use `lambda` instead.'
+        MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
           subject, = *node

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

@@ -39,9 +39,7 @@ module RuboCop
         # if found within a percent literal expression, will cause a
         # NestedPercentLiteral violation to be emitted.
         PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
-        REGEXES = PERCENT_LITERAL_TYPES.map do |percent_literal|
-          /\A#{percent_literal}\W/
-        end.freeze
+        REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
 
         def on_array(node)
           process(node, *PERCENT_LITERAL_TYPES)

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

@@ -66,9 +66,7 @@ module RuboCop
           loop_variable(node.arguments) do |var_name|
             return unless var_is_required?(node.body, var_name)
 
-            add_offense(node.send_node) do |corrector|
-              correct_block(corrector, node.send_node)
-            end
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
           end
         end
 

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

@@ -97,7 +97,7 @@ module RuboCop
 
         def handle_as_symbol(node)
           to_method_symbol(node) do |receiver, sym_node, to_method|
-            next if receiver.nil?
+            next if receiver.nil? || !node.arguments.one?
 
             message = format(
               MSG,
@@ -113,8 +113,7 @@ module RuboCop
         end
 
         def correct_method(node, receiver)
-          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
-                 number_object: receiver.source)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
         end
 
         def correct_sym_method(to_method)

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

@@ -31,8 +31,7 @@ module RuboCop
         include FrozenStringLiteral
         extend AutoCorrector
 
-        MSG = 'The encoding magic comment should precede all other ' \
-              'magic comments.'
+        MSG = 'The encoding magic comment should precede all other magic comments.'
 
         def on_new_investigation
           return if processed_source.buffer.source.empty?

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

@@ -48,9 +48,7 @@ module RuboCop
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)
 
-          @valid_ref = regexp_conditions.map do |condition|
-            check_regexp(condition)
-          end.compact.max
+          @valid_ref = regexp_conditions.map { |condition| check_regexp(condition) }.compact.max
         end
 
         def on_nth_ref(node)

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

@@ -29,9 +29,7 @@ module RuboCop
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
         alias on_csend on_send
 

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

@@ -34,9 +34,7 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_colons_or_commas?(node)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private

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

@@ -45,8 +45,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          exception?(node, &check(node)) ||
-            exception_new_with_message?(node, &check(node))
+          exception?(node, &check(node)) || exception_new_with_message?(node, &check(node))
         end
 
         private

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

@@ -21,8 +21,7 @@ module RuboCop
       #
       #   0 # just use 0 instead
       class RandOne < Base
-        MSG = '`%<method>s` always returns `0`. ' \
-              'Perhaps you meant `rand(2)` or `rand`?'
+        MSG = '`%<method>s` always returns `0`. Perhaps you meant `rand(2)` or `rand`?'
         RESTRICT_ON_SEND = %i[rand].freeze
 
         # @!method rand_one?(node)

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

@@ -60,18 +60,19 @@ module RuboCop
           processed_source.buffer.source_line(range.line - 1).blank?
         end
 
-        def comment_range_with_surrounding_space(range)
-          if previous_line_blank?(range) &&
-             processed_source.comment_config.comment_only_line?(range.line)
+        def comment_range_with_surrounding_space(directive_comment_range, line_comment_range)
+          if previous_line_blank?(directive_comment_range) &&
+             processed_source.comment_config.comment_only_line?(directive_comment_range.line) &&
+             directive_comment_range.begin_pos == line_comment_range.begin_pos
             # When the previous line is blank, it should be retained
-            range_with_surrounding_space(range: range, side: :right)
+            range_with_surrounding_space(range: directive_comment_range, side: :right)
           else
             # Eat the entire comment, the preceding space, and the preceding
             # newline if there is one.
-            original_begin = range.begin_pos
-            range = range_with_surrounding_space(range: range,
-                                                 side: :left,
-                                                 newlines: true)
+            original_begin = directive_comment_range.begin_pos
+            range = range_with_surrounding_space(
+              range: directive_comment_range, side: :left, newlines: true
+            )
 
             range_with_surrounding_space(range: range,
                                          side: :right,
@@ -93,9 +94,7 @@ module RuboCop
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range: range,
-                                       side: :right,
-                                       newlines: false)
+          range_with_surrounding_space(range: range, side: :right, newlines: false)
         end
 
         def each_redundant_disable(cop_disabled_line_ranges, offenses,
@@ -103,13 +102,9 @@ module RuboCop
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
-            each_already_disabled(line_ranges,
-                                  disabled_ranges) do |comment|
-              yield comment, cop
-            end
+            each_already_disabled(line_ranges, disabled_ranges) { |comment| yield comment, cop }
 
-            each_line_range(line_ranges, disabled_ranges, offenses,
-                            cop, &block)
+            each_line_range(line_ranges, disabled_ranges, offenses, cop, &block)
           end
         end
 
@@ -119,8 +114,7 @@ module RuboCop
             comment = processed_source.comment_at_line(line_range.begin)
             next if ignore_offense?(disabled_ranges, line_range)
 
-            redundant_cop = find_redundant(comment, offenses, cop, line_range,
-                                           line_ranges[ix + 1])
+            redundant_cop = find_redundant(comment, offenses, cop, line_range, line_ranges[ix + 1])
             yield comment, redundant_cop if redundant_cop
           end
         end
@@ -151,8 +145,7 @@ module RuboCop
             # comment. If the disable all comment is truly redundant, we will
             # detect that when examining the comments of another cop, and we
             # get the full line range for the disable all.
-            if (next_line_range.nil? ||
-                line_range.last != next_line_range.first) &&
+            if (next_line_range.nil? || line_range.last != next_line_range.first) &&
                offenses.none? { |o| line_range.cover?(o.line) }
               'all'
             end
@@ -180,8 +173,7 @@ module RuboCop
 
         def add_offenses(redundant_cops)
           redundant_cops.each do |comment, cops|
-            if all_disabled?(comment) ||
-               directive_count(comment) == cops.size
+            if all_disabled?(comment) || directive_count(comment) == cops.size
               add_offense_for_entire_comment(comment, cops)
             else
               add_offense_for_some_cops(comment, cops)
@@ -190,14 +182,14 @@ module RuboCop
         end
 
         def add_offense_for_entire_comment(comment, cops)
-          location = comment.loc.expression
+          location = DirectiveComment.new(comment).range
           cop_list = cops.sort.map { |c| describe(c) }
 
           add_offense(
             location,
             message: "Unnecessary disabling of #{cop_list.join(', ')}."
           ) do |corrector|
-            range = comment_range_with_surrounding_space(location)
+            range = comment_range_with_surrounding_space(location, comment.loc.expression)
             corrector.remove(range)
           end
         end
@@ -229,8 +221,7 @@ module RuboCop
           return unless offset
 
           offset += haystack.begin_pos
-          Parser::Source::Range.new(haystack.source_buffer, offset,
-                                    offset + needle.size)
+          Parser::Source::Range.new(haystack.source_buffer, offset, offset + needle.size)
         end
 
         def trailing_range?(ranges, range)