rubocop 0.87.0 → 0.90.0

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

@@ -22,8 +22,9 @@ module RuboCop
       #
       #   # good
       #   alias_method :bar, :foo
-      class Alias < Cop
+      class Alias < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
         MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
@@ -36,31 +37,37 @@ module RuboCop
           return unless style == :prefer_alias && alias_keyword_possible?(node)
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
-          add_offense(node, location: :selector, message: msg)
+          add_offense(node.loc.selector, message: msg) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def on_alias(node)
           return unless alias_method_possible?(node)
 
           if scope_type(node) == :dynamic || style == :prefer_alias_method
-            add_offense(node, location: :keyword, message: MSG_ALIAS)
+            add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
+              autocorrect(corrector, node)
+            end
           elsif node.children.none? { |arg| bareword?(arg) }
-            add_offense_for_args(node)
+            add_offense_for_args(node) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           if node.send_type?
-            correct_alias_method_to_alias(node)
+            correct_alias_method_to_alias(corrector, node)
           elsif scope_type(node) == :dynamic || style == :prefer_alias_method
-            correct_alias_to_alias_method(node)
+            correct_alias_to_alias_method(corrector, node)
           else
-            correct_alias_with_symbol_args(node)
+            correct_alias_with_symbol_args(corrector, node)
           end
         end
 
-        private
-
         def alias_keyword_possible?(node)
           scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
         end
@@ -70,14 +77,14 @@ module RuboCop
             node.children.none?(&:gvar_type?)
         end
 
-        def add_offense_for_args(node)
+        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)
-          add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
+          add_offense(arg_ranges.reduce(&:join), message: msg, &block)
         end
 
         # In this expression, will `self` be the same as the innermost enclosing
@@ -101,41 +108,39 @@ module RuboCop
         end
 
         def lexical_scope_type(node)
-          node.each_ancestor(:class, :module) do |ancestor|
-            return ancestor.class_type? ? 'in a class body' : 'in a module body'
+          ancestor = node.each_ancestor(:class, :module).first
+          if ancestor.nil?
+            'at the top level'
+          elsif ancestor.class_type?
+            'in a class body'
+          else
+            'in a module body'
           end
-          'at the top level'
         end
 
         def bareword?(sym_node)
           !sym_node.source.start_with?(':')
         end
 
-        def correct_alias_method_to_alias(send_node)
-          lambda do |corrector|
-            new, old = *send_node.arguments
-            replacement = "alias #{identifier(new)} #{identifier(old)}"
-            corrector.replace(send_node, replacement)
-          end
+        def correct_alias_method_to_alias(corrector, send_node)
+          new, old = *send_node.arguments
+          replacement = "alias #{identifier(new)} #{identifier(old)}"
+
+          corrector.replace(send_node, replacement)
         end
 
-        def correct_alias_to_alias_method(node)
-          lambda do |corrector|
-            replacement =
-              'alias_method ' \
-              ":#{identifier(node.new_identifier)}, " \
-              ":#{identifier(node.old_identifier)}"
-            corrector.replace(node, replacement)
-          end
+        def correct_alias_to_alias_method(corrector, node)
+          replacement =
+            'alias_method ' \
+            ":#{identifier(node.new_identifier)}, " \
+            ":#{identifier(node.old_identifier)}"
+
+          corrector.replace(node, replacement)
         end
 
-        def correct_alias_with_symbol_args(node)
-          lambda do |corrector|
-            corrector.replace(node.new_identifier,
-                              node.new_identifier.source[1..-1])
-            corrector.replace(node.old_identifier,
-                              node.old_identifier.source[1..-1])
-          end
+        def correct_alias_with_symbol_args(corrector, node)
+          corrector.replace(node.new_identifier, node.new_identifier.source[1..-1])
+          corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
         end
 
         def_node_matcher :identifier, <<~PATTERN

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

@@ -36,9 +36,10 @@ module RuboCop
       #   # good
       #   if foo && bar
       #   end
-      class AndOr < Cop
+      class AndOr < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -55,8 +56,13 @@ module RuboCop
         alias on_until      on_if
         alias on_until_post on_if
 
-        def autocorrect(node)
-          lambda do |corrector|
+        private
+
+        def process_logical_operator(node)
+          return if node.logical_operator?
+
+          message = message(node)
+          add_offense(node.loc.operator, message: message) do |corrector|
             node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
@@ -71,20 +77,12 @@ module RuboCop
           end
         end
 
-        private
-
         def on_conditionals(node)
           node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
             process_logical_operator(operator)
           end
         end
 
-        def process_logical_operator(node)
-          return if node.logical_operator?
-
-          add_offense(node, location: :operator)
-        end
-
         def message(node)
           format(MSG, prefer: node.alternate_operator, current: node.operator)
         end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
+      #
+      # @example
+      #   # bad
+      #   paths = [paths] unless paths.is_a?(Array)
+      #   paths.each { |path| do_something(path) }
+      #
+      #   # bad (always creates a new Array instance)
+      #   [*paths].each { |path| do_something(path) }
+      #
+      #   # good (and a bit more readable)
+      #   Array(paths).each { |path| do_something(path) }
+      #
+      class ArrayCoercion < Base
+        extend AutoCorrector
+
+        SPLAT_MSG = 'Use `Array(%<arg>s)` instead of `[*%<arg>s]`.'
+        CHECK_MSG = 'Use `Array(%<arg>s)` instead of explicit `Array` check.'
+
+        def_node_matcher :array_splat?, <<~PATTERN
+          (array (splat $_))
+        PATTERN
+
+        def_node_matcher :unless_array?, <<~PATTERN
+          (if
+            (send
+              (lvar $_) :is_a?
+              (const nil? :Array)) nil?
+            (lvasgn $_
+              (array
+                (lvar $_))))
+        PATTERN
+
+        def on_array(node)
+          return unless node.square_brackets?
+
+          array_splat?(node) do |arg_node|
+            message = format(SPLAT_MSG, arg: arg_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, "Array(#{arg_node.source})")
+            end
+          end
+        end
+
+        def on_if(node)
+          unless_array?(node) do |var_a, var_b, var_c|
+            if var_a == var_b && var_c == var_b
+              message = format(CHECK_MSG, arg: var_a)
+              add_offense(node, message: message) do |corrector|
+                corrector.replace(node, "#{var_a} = Array(#{var_a})")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,20 +17,18 @@ module RuboCop
       #   # good
       #   %w(foo bar baz).join(",")
       #
-      class ArrayJoin < Cop
+      class ArrayJoin < Base
+        extend AutoCorrector
+
         MSG = 'Favor `Array#join` over `Array#*`.'
 
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 
         def on_send(node)
-          join_candidate?(node) { add_offense(node, location: :selector) }
-        end
-
-        def autocorrect(node)
-          array, join_arg = join_candidate?(node).map(&:source)
+          return unless (array, join_arg = join_candidate?(node))
 
-          lambda do |corrector|
-            corrector.replace(node, "#{array}.join(#{join_arg})")
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node, "#{array.source}.join(#{join_arg.source})")
           end
         end
       end

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

@@ -15,17 +15,17 @@ module RuboCop
       #
       #   # good
       #   # Translates from English to Japanese
-      class AsciiComments < Cop
+      class AsciiComments < Base
         include RangeHelp
 
         MSG = 'Use only ascii symbols in comments.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        def on_new_investigation
+          processed_source.comments.each do |comment|
             next if comment.text.ascii_only?
             next if only_allowed_non_ascii_chars?(comment.text)
 
-            add_offense(comment, location: first_offense_range(comment))
+            add_offense(first_offense_range(comment))
           end
         end
 

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

@@ -14,8 +14,9 @@ module RuboCop
       #   attr_accessor :something
       #   attr_reader :one, :two, :three
       #
-      class Attr < Cop
+      class Attr < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use `attr`. Use `%<replacement>s` instead.'
 
@@ -26,10 +27,15 @@ module RuboCop
                     !node.parent.class_type? &&
                     !class_eval?(node.parent)
 
-          add_offense(node, location: :selector)
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 
           node_expr = node.source_range
@@ -37,14 +43,10 @@ module RuboCop
 
           remove = range_between(attr_expr.end_pos, node_expr.end_pos) if setter&.boolean_type?
 
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement_method(node))
-            corrector.remove(remove) if remove
-          end
+          corrector.replace(node.loc.selector, replacement_method(node))
+          corrector.remove(remove) if remove
         end
 
-        private
-
         def message(node)
           format(MSG, replacement: replacement_method(node))
         end

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

@@ -16,7 +16,7 @@ module RuboCop
       #   File.open('file') do |f|
       #     # ...
       #   end
-      class AutoResourceCleanup < Cop
+      class AutoResourceCleanup < Base
         MSG = 'Use the block version of `%<class>s.%<method>s`.'
 
         TARGET_METHODS = {
@@ -25,16 +25,14 @@ module RuboCop
 
         def on_send(node)
           TARGET_METHODS.each do |target_class, target_method|
-            target_receiver = s(:const, nil, target_class)
+            next if node.method_name != target_method
 
+            target_receiver = s(:const, nil, target_class)
             next if node.receiver != target_receiver
-            next if node.method_name != target_method
+
             next if cleanup?(node)
 
-            add_offense(node,
-                        message: format(MSG,
-                                        class: target_class,
-                                        method: target_method))
+            add_offense(node, message: format(MSG, class: target_class, method: target_method))
           end
         end
 

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

@@ -23,8 +23,9 @@ module RuboCop
       #   %Q|He said: "#{greeting}"|
       #   %q/She said: 'Hi'/
       #
-      class BarePercentLiterals < Cop
+      class BarePercentLiterals < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use `%%%<good>s` instead of `%%%<bad>s`.'
 
@@ -36,14 +37,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          src = node.loc.begin.source
-          replacement = src.start_with?('%Q') ? '%' : '%Q'
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, src.sub(/%Q?/, replacement))
-          end
-        end
-
         private
 
         def check(node)
@@ -68,9 +61,14 @@ module RuboCop
         end
 
         def add_offense_for_wrong_style(node, good, bad)
-          add_offense(node, location: :begin, message: format(MSG,
-                                                              good: good,
-                                                              bad: bad))
+          location = node.loc.begin
+
+          add_offense(location, message: format(MSG, good: good, bad: bad)) do |corrector|
+            source = location.source
+            replacement = source.start_with?('%Q') ? '%' : '%Q'
+
+            corrector.replace(location, source.sub(/%Q?/, replacement))
+          end
         end
       end
     end

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

@@ -10,11 +10,11 @@ module RuboCop
       #   # bad
       #   BEGIN { test }
       #
-      class BeginBlock < Cop
+      class BeginBlock < Base
         MSG = 'Avoid the use of `BEGIN` blocks.'
 
         def on_preexe(node)
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword)
         end
       end
     end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Style
@@ -20,40 +18,39 @@ module RuboCop
       #     attr_accessor :bar
       #   end
       #
-      class BisectedAttrAccessor < Cop
-        MSG = 'Combine both accessors into `attr_accessor :%<name>s`.'
+      class BisectedAttrAccessor < Base
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
 
         def on_class(class_node)
-          reader_names, writer_names = accessor_names(class_node)
+          VISIBILITY_SCOPES.each do |visibility|
+            reader_names, writer_names = accessor_names(class_node, visibility)
+            next unless reader_names && writer_names
 
-          accessor_macroses(class_node).each do |macro|
-            check(macro, reader_names, writer_names)
+            accessor_macroses(class_node, visibility).each do |macro|
+              check(macro, reader_names, writer_names)
+            end
           end
         end
+        alias on_sclass on_class
         alias on_module on_class
 
-        def autocorrect(node)
-          macro = node.parent
-
-          lambda do |corrector|
-            corrector.replace(macro, replacement(macro, node))
-          end
-        end
-
         private
 
-        def accessor_names(class_node)
-          reader_names = Set.new
-          writer_names = Set.new
+        def accessor_names(class_node, visibility)
+          reader_names = nil
+          writer_names = nil
 
-          accessor_macroses(class_node).each do |macro|
-            names = macro.arguments.map(&:value)
+          accessor_macroses(class_node, visibility).each do |macro|
+            names = macro.arguments.map(&:source)
 
             names.each do |name|
               if attr_reader?(macro)
-                reader_names.add(name)
+                (reader_names ||= Set.new).add(name)
               else
-                writer_names.add(name)
+                (writer_names ||= Set.new).add(name)
               end
             end
           end
@@ -61,7 +58,7 @@ module RuboCop
           [reader_names, writer_names]
         end
 
-        def accessor_macroses(class_node)
+        def accessor_macroses(class_node, visibility)
           class_def = class_node.body
           return [] if !class_def || class_def.def_type?
 
@@ -72,7 +69,13 @@ module RuboCop
               class_def.each_child_node(:send)
             end
 
-          send_nodes.select { |node| node.macro? && (attr_reader?(node) || attr_writer?(node)) }
+          send_nodes.select { |node| attr_within_visibility_scope?(node, visibility) }
+        end
+
+        def attr_within_visibility_scope?(node, visibility)
+          node.macro? &&
+            (attr_reader?(node) || attr_writer?(node)) &&
+            node_visibility(node) == visibility
         end
 
         def attr_reader?(send_node)
@@ -85,30 +88,47 @@ module RuboCop
 
         def check(macro, reader_names, writer_names)
           macro.arguments.each do |arg_node|
-            name = arg_node.value
+            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
 
-            if (attr_reader?(macro) && writer_names.include?(name)) ||
-               (attr_writer?(macro) && reader_names.include?(name))
-              add_offense(arg_node, message: format(MSG, name: name))
+              corrector.replace(macro, replacement(macro, arg_node))
             end
           end
         end
 
         def replacement(macro, node)
-          rest_args = macro.arguments
-          rest_args.delete(node)
-          args = rest_args.map(&:source).join(', ')
+          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)
-            if args.empty?
-              "attr_accessor #{node.source}"
-            else
-              "attr_accessor #{node.source}\n#{indent(macro)}#{macro.method_name} #{args}"
-            end
-          elsif args.empty?
+            attr_reader_replacement(macro, node, rest_args)
+          elsif rest_args.empty?
             ''
           else
-            "#{indent(macro)}#{macro.method_name} #{args}"
+            "#{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)
+          end
+        end
+
+        def attr_reader_replacement(macro, node, rest_args)
+          if rest_args.empty?
+            "attr_accessor #{node.source}"
+          else
+            "attr_accessor #{node.source}\n"\
+            "#{indent(macro)}#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
           end
         end