rubocop 1.12.0 → 1.16.0

data/lib/rubocop/cop/naming/method_name.rb

@@ -53,8 +53,7 @@ module RuboCop
         end
 
         def on_def(node)
-          return if node.operator_method? ||
-                    matches_ignored_pattern?(node.method_name)
+          return if node.operator_method? || matches_ignored_pattern?(node.method_name)
 
           check_name(node, node.method_name, node.loc.name)
         end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -44,8 +44,7 @@ module RuboCop
 
               add_offense(
                 node.first_argument.loc.expression,
-                message: message(method_name,
-                                 expected_name(method_name.to_s, prefix))
+                message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end
           end

data/lib/rubocop/cop/offense.rb

@@ -7,8 +7,7 @@ module RuboCop
       include Comparable
 
       # @api private
-      COMPARISON_ATTRIBUTES = %i[line column cop_name
-                                 message severity].freeze
+      COMPARISON_ATTRIBUTES = %i[line column cop_name message severity].freeze
 
       # @api public
       #
@@ -141,9 +140,7 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the range of the code that is highlighted
       def highlighted_area
-        Parser::Source::Range.new(source_line,
-                                  column,
-                                  column + column_length)
+        Parser::Source::Range.new(source_line, column, column + column_length)
       end
 
       # @api private
@@ -220,9 +217,7 @@ module RuboCop
       alias eql? ==
 
       def hash
-        COMPARISON_ATTRIBUTES.reduce(0) do |hash, attribute|
-          hash ^ public_send(attribute).hash
-        end
+        COMPARISON_ATTRIBUTES.reduce(0) { |hash, attribute| hash ^ public_send(attribute).hash }
       end
 
       # @api public

data/lib/rubocop/cop/registry.rb

@@ -10,12 +10,7 @@ module RuboCop
 
       def initialize(name, origin, badges)
         super(
-          format(
-            MSG,
-            name: name,
-            origin: origin,
-            options: badges.to_a.join(' or ')
-          )
+          format(MSG, name: name, origin: origin, options: badges.to_a.join(' or '))
         )
       end
     end
@@ -155,16 +150,13 @@ module RuboCop
       end
 
       def enabled(config, only = [], only_safe: false)
-        select do |cop|
-          only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
-        end
+        select { |cop| only.include?(cop.cop_name) || enabled?(cop, config, only_safe) }
       end
 
       def enabled?(cop, config, only_safe)
         cfg = config.for_cop(cop)
 
-        cop_enabled = cfg.fetch('Enabled') == true ||
-                      enabled_pending_cop?(cfg, config)
+        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
 
         if only_safe
           cop_enabled && cfg.fetch('Safe', true)

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

@@ -47,7 +47,7 @@ module RuboCop
       #
       #   end
       #
-      # @example AllowModifiersOnSymbols: true
+      # @example AllowModifiersOnSymbols: true (default)
       #   # good
       #   class Foo
       #
@@ -88,9 +88,7 @@ module RuboCop
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) do
-              opposite_style_detected
-            end
+            add_offense(node.loc.selector) { opposite_style_detected }
           else
             correct_style_detected
           end

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

@@ -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
 

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

@@ -94,7 +94,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

@@ -107,9 +107,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/ascii_comments.rb

@@ -35,8 +35,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)

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|

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

@@ -18,9 +18,7 @@ module RuboCop
 
           def initialize(node)
             @node = node
-            @attrs = node.arguments.map do |attr|
-              [attr.source, attr]
-            end.to_h
+            @attrs = node.arguments.map { |attr| [attr.source, attr] }.to_h
             @bisection = []
           end
 

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

@@ -221,8 +221,7 @@ module RuboCop
           name = node.children[1].to_s
 
           # We can no be sure if, e.g. `C`, represents a constant or a class reference
-          name.length > 1 &&
-            name == name.upcase
+          name.length > 1 && name == name.upcase
         end
 
         def class_reference?(node)

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

@@ -18,13 +18,11 @@ module RuboCop
         include StringHelp
         extend AutoCorrector
 
-        MSG = 'Do not use the character literal - ' \
-              'use string literal instead.'
+        MSG = 'Do not use the character literal - use string literal instead.'
 
         def offense?(node)
           # we don't register an offense for things like ?\C-\M-d
-          node.loc.begin.is?('?') &&
-            node.source.size.between?(2, 3)
+          node.loc.begin.is?('?') && node.source.size.between?(2, 3)
         end
 
         def autocorrect(corrector, node)

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

@@ -26,10 +26,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        NESTED_MSG = 'Use nested module/class definitions instead of ' \
-                     'compact style.'
-        COMPACT_MSG = 'Use compact module/class definition instead of ' \
-                      'nested style.'
+        NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
+        COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
         def on_class(node)
           return if node.parent_class && style != :nested
@@ -89,10 +87,18 @@ module RuboCop
         end
 
         def compact_node(corrector, node)
+          range = range_between(node.loc.keyword.begin_pos, node.body.loc.name.end_pos)
+          corrector.replace(range, compact_replacement(node))
+        end
+
+        def compact_replacement(node)
           replacement = "#{node.body.type} #{compact_identifier_name(node)}"
-          range = range_between(node.loc.keyword.begin_pos,
-                                node.body.loc.name.end_pos)
-          corrector.replace(range, replacement)
+
+          body_comments = processed_source.ast_with_comments[node.body]
+          unless body_comments.empty?
+            replacement = body_comments.map(&:text).push(replacement).join("\n")
+          end
+          replacement
         end
 
         def compact_identifier_name(node)
@@ -135,7 +141,10 @@ module RuboCop
         end
 
         def check_compact_style(node, body)
-          return unless one_child?(body) && !compact_node_name?(node)
+          parent = node.parent
+          return if parent&.class_type? || parent&.module_type?
+
+          return unless needs_compacting?(body)
 
           add_offense(node.loc.name, message: COMPACT_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -148,12 +157,12 @@ module RuboCop
           nest_or_compact(corrector, node)
         end
 
-        def one_child?(body)
+        def needs_compacting?(body)
           body && %i[module class].include?(body.type)
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.loc.name.source)
+          /::/.match?(node.identifier.source)
         end
       end
     end

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

@@ -31,9 +31,7 @@ module RuboCop
           if node.body.defs_type?
             check_defs(node.identifier, node.body)
           elsif node.body.begin_type?
-            node.body.each_child_node(:defs) do |def_node|
-              check_defs(node.identifier, def_node)
-            end
+            node.body.each_child_node(:defs) { |def_node| check_defs(node.identifier, def_node) }
           end
         end
         alias on_module on_class

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

@@ -69,9 +69,7 @@ module RuboCop
           good = good_method_name(method_name)
           message = format(MSG, good: good, bad: range.source)
 
-          add_offense(range, message: message) do |corrector|
-            corrector.replace(range, good)
-          end
+          add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
         end
 
         private

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

@@ -38,9 +38,7 @@ module RuboCop
           # ignore Java interop code like Java::int
           return if java_type_node?(node)
 
-          add_offense(node.loc.dot) do |corrector|
-            corrector.replace(node.loc.dot, '.')
-          end
+          add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
       end
     end

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

@@ -75,8 +75,9 @@ module RuboCop
         private
 
         def collection_looping_method?(node)
-          method_name = node.send_node.method_name
-          method_name.match?(/^each/) || method_name.match?(/_each$/)
+          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
+          method_name = node.send_node.method_name.to_s
+          method_name.start_with?('each') || method_name.end_with?('_each')
         end
 
         def same_collection_looping?(node, sibling)

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

@@ -97,17 +97,13 @@ module RuboCop
         def check_backtick_literal(node, message)
           return if allowed_backtick_literal?(node)
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         def check_percent_x_literal(node, message)
           return if allowed_percent_x_literal?(node)
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -177,8 +173,7 @@ module RuboCop
         end
 
         def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']
+          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
         end
       end
     end

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

@@ -44,8 +44,7 @@ module RuboCop
         MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
               'upper case, followed by a colon, and a space, ' \
               'then a note describing the problem.'
-        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
-                       'is missing a note.'
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, is missing a note.'
 
         def on_new_investigation
           processed_source.comments.each_with_index do |comment, index|
@@ -53,8 +52,7 @@ module RuboCop
                         inline_comment?(comment)
 
             margin, first_word, colon, space, note = split_comment(comment)
-            next unless annotation?(comment) &&
-                        !correct_annotation?(first_word, colon, space, note)
+            next unless annotation?(comment) && !correct_annotation?(first_word, colon, space, note)
 
             range = annotation_range(comment, margin, first_word, colon, space)
 
@@ -76,8 +74,7 @@ module RuboCop
         end
 
         def first_comment_line?(comments, index)
-          index.zero? ||
-            comments[index - 1].loc.line < comments[index].loc.line - 1
+          index.zero? || comments[index - 1].loc.line < comments[index].loc.line - 1
         end
 
         def inline_comment?(comment)

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

@@ -40,8 +40,13 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not place comments on the same line as the ' \
-              '`%<keyword>s` keyword.'
+        MSG = 'Do not place comments on the same line as the `%<keyword>s` keyword.'
+
+        KEYWORDS = %w[begin class def end module].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
+
+        ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable rubocop:todo].freeze
+        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -53,17 +58,6 @@ module RuboCop
 
         private
 
-        KEYWORDS = %w[begin class def end module].freeze
-        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
-
-        ALLOWED_COMMENTS = %w[
-          :nodoc:
-          :yields:
-          rubocop:disable
-          rubocop:todo
-        ].freeze
-        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
-
         def register_offense(comment, matched_keyword)
           add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
             range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)