rubocop 1.10.0 → 1.14.0

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

@@ -19,47 +19,61 @@ module RuboCop
       #   end
       #
       class BisectedAttrAccessor < Base
-        include VisibilityHelp
+        require_relative 'bisected_attr_accessor/macro'
+
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
 
+        def on_new_investigation
+          @macros_to_rewrite = {}
+        end
+
         def on_class(class_node)
-          VISIBILITY_SCOPES.each do |visibility|
-            reader_names, writer_names = accessor_names(class_node, visibility)
-            next unless reader_names && writer_names
+          @macros_to_rewrite[class_node] = Set.new
+
+          find_macros(class_node.body).each do |_visibility, macros|
+            bisected = find_bisection(macros)
+            next unless bisected.any?
 
-            accessor_macroses(class_node, visibility).each do |macro|
-              check(macro, reader_names, writer_names)
+            macros.each do |macro|
+              attrs = macro.bisect(*bisected)
+              next if attrs.none?
+
+              @macros_to_rewrite[class_node] << macro
+              attrs.each { |attr| register_offense(attr) }
             end
           end
         end
         alias on_sclass on_class
         alias on_module on_class
 
-        private
-
-        def accessor_names(class_node, visibility)
-          reader_names = nil
-          writer_names = nil
-
-          accessor_macroses(class_node, visibility).each do |macro|
-            names = macro.arguments.map(&:source)
-
-            names.each do |name|
-              if attr_reader?(macro)
-                (reader_names ||= Set.new).add(name)
+        # Each offending macro is captured and registered in `on_class` but correction
+        # happens in `after_class` because a macro might have multiple attributes
+        # rewritten from it
+        def after_class(class_node)
+          @macros_to_rewrite[class_node].each do |macro|
+            node = macro.node
+            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+
+            correct(range) do |corrector|
+              if macro.writer?
+                correct_writer(corrector, macro, node, range)
               else
-                (writer_names ||= Set.new).add(name)
+                correct_reader(corrector, macro, node, range)
               end
             end
           end
-
-          [reader_names, writer_names]
         end
+        alias after_sclass after_class
+        alias after_module after_class
 
-        def accessor_macroses(class_node, visibility)
-          class_def = class_node.body
+        private
+
+        def find_macros(class_def)
+          # Find all the macros (`attr_reader`, `attr_writer`, etc.) in the class body
+          # and turn them into `Macro` objects so that they can be processed.
           return [] if !class_def || class_def.def_type?
 
           send_nodes =
@@ -69,66 +83,40 @@ module RuboCop
               class_def.each_child_node(:send)
             end
 
-          send_nodes.select { |node| attr_within_visibility_scope?(node, visibility) }
+          send_nodes.each_with_object([]) do |node, macros|
+            macros << Macro.new(node) if Macro.macro?(node)
+          end.group_by(&:visibility)
         end
 
-        def attr_within_visibility_scope?(node, visibility)
-          node.macro? &&
-            (attr_reader?(node) || attr_writer?(node)) &&
-            node_visibility(node) == visibility
+        def find_bisection(macros)
+          # Find which attributes are defined in both readers and writers so that they
+          # can be replaced with accessors.
+          readers, writers = macros.partition(&:reader?)
+          readers.flat_map(&:attr_names) & writers.flat_map(&:attr_names)
         end
 
-        def attr_reader?(send_node)
-          send_node.method?(:attr_reader) || send_node.method?(:attr)
+        def register_offense(attr)
+          add_offense(attr, message: format(MSG, name: attr.source))
         end
 
-        def attr_writer?(send_node)
-          send_node.method?(:attr_writer)
-        end
+        def correct_reader(corrector, macro, node, range)
+          attr_accessor = "attr_accessor #{macro.bisected_names.join(', ')}\n"
 
-        def check(macro, reader_names, writer_names)
-          macro.arguments.each do |arg_node|
-            name = arg_node.source
-
-            next unless (attr_reader?(macro) && writer_names.include?(name)) ||
-                        (attr_writer?(macro) && reader_names.include?(name))
-
-            add_offense(arg_node, message: format(MSG, name: name)) do |corrector|
-              macro = arg_node.parent
-
-              corrector.replace(macro, replacement(macro, arg_node))
-            end
-          end
-        end
-
-        def replacement(macro, node)
-          class_node = macro.each_ancestor(:class, :sclass, :module).first
-          reader_names, writer_names = accessor_names(class_node, node_visibility(macro))
-
-          rest_args = rest_args(macro.arguments, reader_names, writer_names)
-
-          if attr_reader?(macro)
-            attr_reader_replacement(macro, node, rest_args)
-          elsif rest_args.empty?
-            ''
+          if macro.all_bisected?
+            corrector.replace(range, "#{indent(node)}#{attr_accessor}")
           else
-            "#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
-          end
-        end
-
-        def rest_args(args, reader_names, writer_names)
-          args.reject do |arg|
-            name = arg.source
-            reader_names.include?(name) && writer_names.include?(name)
+            correction = "#{indent(node)}attr_reader #{macro.rest.join(', ')}"
+            corrector.insert_before(node, attr_accessor)
+            corrector.replace(node, correction)
           end
         end
 
-        def attr_reader_replacement(macro, node, rest_args)
-          if rest_args.empty?
-            "attr_accessor #{node.source}"
+        def correct_writer(corrector, macro, node, range)
+          if macro.all_bisected?
+            corrector.remove(range)
           else
-            "attr_accessor #{node.source}\n"\
-            "#{indent(macro)}#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+            correction = "attr_writer #{macro.rest.join(', ')}"
+            corrector.replace(node, correction)
           end
         end
       end

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_equality.rb

@@ -35,6 +35,7 @@ module RuboCop
         MSG = 'Avoid the use of the case equality operator `===`.'
         RESTRICT_ON_SEND = %i[===].freeze
 
+        # @!method case_equality?(node)
         def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
@@ -64,7 +65,7 @@ module RuboCop
             # The automatic correction from `a === b` to `a.match?(b)` needs to
             # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
             # This correction is expected to be supported by `Performance/Regexp` cop.
-            # See: https://github.com/rubocop-hq/rubocop-performance/issues/152
+            # See: https://github.com/rubocop/rubocop-performance/issues/152
             #
             # So here is noop.
           when :begin

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
@@ -90,8 +88,7 @@ module RuboCop
 
         def compact_node(corrector, node)
           replacement = "#{node.body.type} #{compact_identifier_name(node)}"
-          range = range_between(node.loc.keyword.begin_pos,
-                                node.body.loc.name.end_pos)
+          range = range_between(node.loc.keyword.begin_pos, node.body.loc.name.end_pos)
           corrector.replace(range, replacement)
         end
 
@@ -135,7 +132,7 @@ module RuboCop
         end
 
         def check_compact_style(node, body)
-          return unless one_child?(body) && !compact_node_name?(node)
+          return unless needs_compacting?(body)
 
           add_offense(node.loc.name, message: COMPACT_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -148,12 +145,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

@@ -25,6 +25,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[== equal? eql?].freeze
 
+        # @!method class_comparison_candidate?(node)
         def_node_matcher :class_comparison_candidate?, <<~PATTERN
           (send
             {$(send _ :class) (send $(send _ :class) :name)}
@@ -49,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

@@ -35,6 +35,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
 
+        # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
@@ -44,6 +45,7 @@ module RuboCop
               $(lvar _) :nil?))
         PATTERN
 
+        # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
@@ -67,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

@@ -22,6 +22,7 @@ module RuboCop
 
         MSG = 'Do not use `::` for method calls.'
 
+        # @!method java_type_node?(node)
         def_node_matcher :java_type_node?, <<~PATTERN
           (send
             (const nil? :Java) _)
@@ -37,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