rubocop 1.11.0 → 1.15.0

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/case_like_if.rb

@@ -105,8 +105,7 @@ module RuboCop
           when :===
             node.arguments.first
           when :include?, :cover?
-            receiver = deparenthesize(node.receiver)
-            node.arguments.first if receiver.range_type?
+            find_target_in_include_or_cover_node(node)
           when :match, :match?, :=~
             find_target_in_match_node(node)
           end
@@ -124,6 +123,12 @@ module RuboCop
           end
         end
 
+        def find_target_in_include_or_cover_node(node)
+          return unless (receiver = node.receiver)
+
+          node.first_argument if deparenthesize(receiver).range_type?
+        end
+
         def find_target_in_match_node(node)
           argument = node.arguments.first
           receiver = node.receiver
@@ -167,8 +172,7 @@ module RuboCop
             lhs, _method, rhs = *node
             lhs if rhs == target
           when :include?, :cover?
-            receiver = deparenthesize(node.receiver)
-            receiver if receiver.range_type? && node.arguments.first == target
+            condition_from_include_or_cover_node(node, target)
           end
         end
         # rubocop:enable Metrics/CyclomaticComplexity
@@ -184,6 +188,13 @@ module RuboCop
           condition_from_binary_op(lhs, rhs, target)
         end
 
+        def condition_from_include_or_cover_node(node, target)
+          return unless (receiver = node.receiver)
+
+          receiver = deparenthesize(receiver)
+          receiver if receiver.range_type? && node.first_argument == target
+        end
+
         def condition_from_binary_op(lhs, rhs, target)
           lhs = deparenthesize(lhs)
           rhs = deparenthesize(rhs)
@@ -210,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_equality_comparison.rb

@@ -50,6 +50,8 @@ module RuboCop
 
         def class_name(class_node, node)
           if node.children.first.method?(:name)
+            return class_node.receiver.source if class_node.receiver
+
             class_node.source.delete('"').delete("'")
           else
             class_node.source

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)
@@ -165,7 +161,7 @@ module RuboCop
         end
 
         def preferred_delimiter
-          (command_delimiter || default_delimiter).split('')
+          (command_delimiter || default_delimiter).chars
         end
 
         def command_delimiter
@@ -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)

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

@@ -103,8 +103,7 @@ module RuboCop
         end
 
         def setter_method?(method_name)
-          method_name.to_s.end_with?(EQUAL) &&
-            !%i[!= == === >= <=].include?(method_name)
+          method_name.to_s.end_with?(EQUAL) && !%i[!= == === >= <=].include?(method_name)
         end
 
         def assignment_rhs_exist?(node)
@@ -214,14 +213,10 @@ module RuboCop
         include IgnoredNode
         extend AutoCorrector
 
-        MSG = 'Use the return of the conditional for variable assignment ' \
-              'and comparison.'
-        ASSIGN_TO_CONDITION_MSG =
-          'Assign variables inside of conditionals'
-        VARIABLE_ASSIGNMENT_TYPES =
-          %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
-        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
-                           %i[and_asgn or_asgn op_asgn masgn].freeze
+        MSG = 'Use the return of the conditional for variable assignment and comparison.'
+        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals'
+        VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
+        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
         INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
@@ -368,9 +363,7 @@ module RuboCop
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -411,9 +404,7 @@ module RuboCop
 
         def longest_line(node, assignment)
           assignment_regex = /\s*#{Regexp.escape(assignment).gsub('\ ', '\s*')}/
-          lines = node.source.lines.map do |line|
-            line.chomp.sub(assignment_regex, '')
-          end
+          lines = node.source.lines.map { |line| line.chomp.sub(assignment_regex, '') }
           longest_line = lines.max_by(&:length)
           assignment + longest_line
         end
@@ -457,9 +448,7 @@ module RuboCop
           expression = node.loc.expression
           begin_pos = expression.begin_pos - (expression.column - column - 2)
 
-          Parser::Source::Range.new(expression.source_buffer,
-                                    begin_pos,
-                                    expression.begin_pos)
+          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
         end
 
         def assignment(node)
@@ -532,9 +521,7 @@ module RuboCop
             _variable, *_operator, if_rhs = *node.if_branch
             _else_variable, *_operator, else_rhs = *node.else_branch
 
-            expr = "#{node.condition.source} ? " \
-                   "#{if_rhs.source} : " \
-                   "#{else_rhs.source}"
+            expr = "#{node.condition.source} ? #{if_rhs.source} : #{else_rhs.source}"
 
             element_assignment?(node.if_branch) ? "(#{expr})" : expr
           end
@@ -596,8 +583,7 @@ module RuboCop
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment,
-                                    assignment.source)
+            corrector.insert_before(branch_assignment, assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 

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

@@ -19,10 +19,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
-              'any code.'
-        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
-                                    'your RuboCop config'
+        MSG = 'Include a copyright notice matching /%<notice>s/ before any code.'
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in your RuboCop config'
 
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
@@ -57,8 +55,7 @@ module RuboCop
           regex = Regexp.new(notice)
           return if autocorrect_notice&.match?(regex)
 
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                         "match Notice /#{notice}/"
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
         end
 
         def insert_notice_before(processed_source)