rubocop 0.88.0 → 0.91.1

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,10 +14,12 @@ 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.'
+        RESTRICT_ON_SEND = %i[attr].freeze
 
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
@@ -26,10 +28,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 +44,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,13 +16,15 @@ 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 = {
           File: :open
         }.freeze
 
+        RESTRICT_ON_SEND = TARGET_METHODS.values.freeze
+
         def on_send(node)
           TARGET_METHODS.each do |target_class, target_method|
             next if node.method_name != target_method
@@ -32,10 +34,7 @@ module RuboCop
 
             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,8 +18,9 @@ module RuboCop
       #     attr_accessor :bar
       #   end
       #
-      class BisectedAttrAccessor < Cop
+      class BisectedAttrAccessor < Base
         include VisibilityHelp
+        extend AutoCorrector
 
         MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
 
@@ -38,14 +37,6 @@ module RuboCop
         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, visibility)
@@ -99,9 +90,13 @@ module RuboCop
           macro.arguments.each do |arg_node|
             name = arg_node.source
 
-            if (attr_reader?(macro) && writer_names.include?(name)) ||
-               (attr_writer?(macro) && reader_names.include?(name))
-              add_offense(arg_node, message: format(MSG, name: name))
+            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

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

@@ -16,34 +16,30 @@ module RuboCop
       #   # Multiple lines
       #   # of comments...
       #
-      class BlockComments < Cop
+      class BlockComments < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use block comments.'
         BEGIN_LENGTH = "=begin\n".length
         END_LENGTH = "\n=end".length
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        def on_new_investigation
+          processed_source.comments.each do |comment|
             next unless comment.document?
 
-            add_offense(comment)
-          end
-        end
-
-        def autocorrect(comment)
-          eq_begin, eq_end, contents = parts(comment)
+            add_offense(comment) do |corrector|
+              eq_begin, eq_end, contents = parts(comment)
 
-          lambda do |corrector|
-            corrector.remove(eq_begin)
-            unless contents.length.zero?
-              corrector.replace(contents,
-                                contents.source
-                                  .gsub(/\A/, '# ')
-                                  .gsub(/\n\n/, "\n#\n")
-                                  .gsub(/\n(?=[^#])/, "\n# "))
+              corrector.remove(eq_begin)
+              unless contents.length.zero?
+                corrector.replace(
+                  contents,
+                  contents.source.gsub(/\A/, '# ').gsub(/\n\n/, "\n#\n").gsub(/\n(?=[^#])/, "\n# ")
+                )
+              end
+              corrector.remove(eq_end)
             end
-            corrector.remove(eq_end)
           end
         end
 

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

@@ -132,14 +132,14 @@ module RuboCop
       #     puts foo
       #   end
       #
-      class BlockDelimiters < Cop
+      class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        extend AutoCorrector
 
         ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
 
-        BRACES_REQUIRED_MESSAGE = 'Brace delimiters `{...}` required for ' \
-          "'%<method_name>s' method."
+        BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
         def on_send(node)
           return unless node.arguments?
@@ -158,22 +158,26 @@ module RuboCop
 
         def on_block(node)
           return if ignored_node?(node)
+          return if proper_block_style?(node)
 
-          add_offense(node, location: :begin) unless proper_block_style?(node)
+          message = message(node)
+          add_offense(node.loc.begin, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return if correction_would_break_code?(node)
 
           if node.braces?
-            replace_braces_with_do_end(node.loc)
+            replace_braces_with_do_end(corrector, node.loc)
           else
-            replace_do_end_with_braces(node.loc)
+            replace_do_end_with_braces(corrector, node.loc)
           end
         end
 
-        private
-
         def line_count_based_message(node)
           if node.multiline?
             'Avoid using `{...}` for multi-line blocks.'
@@ -219,29 +223,25 @@ module RuboCop
           end
         end
 
-        def replace_braces_with_do_end(loc)
+        def replace_braces_with_do_end(corrector, loc)
           b = loc.begin
           e = loc.end
 
-          lambda do |corrector|
-            corrector.insert_before(b, ' ') unless whitespace_before?(b)
-            corrector.insert_before(e, ' ') unless whitespace_before?(e)
-            corrector.insert_after(b, ' ') unless whitespace_after?(b)
-            corrector.replace(b, 'do')
-            corrector.replace(e, 'end')
-          end
+          corrector.insert_before(b, ' ') unless whitespace_before?(b)
+          corrector.insert_before(e, ' ') unless whitespace_before?(e)
+          corrector.insert_after(b, ' ') unless whitespace_after?(b)
+          corrector.replace(b, 'do')
+          corrector.replace(e, 'end')
         end
 
-        def replace_do_end_with_braces(loc)
+        def replace_do_end_with_braces(corrector, loc)
           b = loc.begin
           e = loc.end
 
-          lambda do |corrector|
-            corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
+          corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
 
-            corrector.replace(b, '{')
-            corrector.replace(e, '}')
-          end
+          corrector.replace(b, '{')
+          corrector.replace(e, '}')
         end
 
         def whitespace_before?(range)

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

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   something.is_a?(Array)
       #   (1..100).include?(7)
-      #   some_string =~ /something/
+      #   /something/.match?(some_string)
       #
       # @example AllowOnConstant
       #   # Style/CaseEquality:
@@ -27,15 +27,25 @@ module RuboCop
       #   # good
       #   Array === something
       #   (1..100).include?(7)
-      #   some_string =~ /something/
+      #   /something/.match?(some_string)
       #
-      class CaseEquality < Cop
+      class CaseEquality < Base
+        extend AutoCorrector
+
         MSG = 'Avoid the use of the case equality operator `===`.'
+        RESTRICT_ON_SEND = %i[===].freeze
 
-        def_node_matcher :case_equality?, '(send #const? :=== _)'
+        def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
-          case_equality?(node) { add_offense(node, location: :selector) }
+          case_equality?(node) do |lhs, rhs|
+            return if lhs.const_type? && !lhs.module_name?
+
+            add_offense(node.loc.selector) do |corrector|
+              replacement = replacement(lhs, rhs)
+              corrector.replace(node, replacement) if replacement
+            end
+          end
         end
 
         private
@@ -47,6 +57,23 @@ module RuboCop
             true
           end
         end
+
+        def replacement(lhs, rhs)
+          case lhs.type
+          when :regexp
+            # 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
+            #
+            # So here is noop.
+          when :begin
+            child = lhs.children.first
+            "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?
+          when :const
+            "#{rhs.source}.is_a?(#{lhs.source})"
+          end
+        end
       end
     end
   end

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

@@ -26,8 +26,9 @@ module RuboCop
       #     final_action
       #   end
       #
-      class CaseLikeIf < Cop
+      class CaseLikeIf < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Convert `if-elsif` to `case-when`.'
 
@@ -46,28 +47,30 @@ module RuboCop
             break unless convertible
           end
 
-          add_offense(node) if convertible
+          return unless convertible
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           target = find_target(node.condition)
 
-          lambda do |corrector|
-            corrector.insert_before(node, "case #{target.source}\n#{indent(node)}")
+          corrector.insert_before(node, "case #{target.source}\n#{indent(node)}")
 
-            branch_conditions(node).each do |branch_condition|
-              conditions = []
-              collect_conditions(branch_condition, target, conditions)
+          branch_conditions(node).each do |branch_condition|
+            conditions = []
+            collect_conditions(branch_condition, target, conditions)
 
-              range = correction_range(branch_condition)
-              branch_replacement = "when #{conditions.map(&:source).join(', ')}"
-              corrector.replace(range, branch_replacement)
-            end
+            range = correction_range(branch_condition)
+            branch_replacement = "when #{conditions.map(&:source).join(', ')}"
+            corrector.replace(range, branch_replacement)
           end
         end
 
-        private
-
         def should_check?(node)
           !node.unless? && !node.elsif? && !node.modifier_form? && !node.ternary? &&
             node.elsif_conditional?
@@ -112,6 +115,7 @@ module RuboCop
         def find_target_in_equality_node(node)
           argument = node.arguments.first
           receiver = node.receiver
+          return unless argument && receiver
 
           if argument.literal? || const_reference?(argument)
             receiver
@@ -123,6 +127,7 @@ module RuboCop
         def find_target_in_match_node(node)
           argument = node.arguments.first
           receiver = node.receiver
+          return unless receiver
 
           if receiver.regexp_type?
             argument
@@ -149,15 +154,15 @@ module RuboCop
           conditions << condition if condition
         end
 
-        # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/CyclomaticComplexity
         def condition_from_send_node(node, target)
           case node.method_name
           when :is_a?
             node.arguments.first if node.receiver == target
-          when :==, :eql?, :equal?, :=~, :match, :match?
-            lhs, _method, rhs = *node
-            condition_from_binary_op(lhs, rhs, target)
+          when :==, :eql?, :equal?
+            condition_from_equality_node(node, target)
+          when :=~, :match, :match?
+            condition_from_match_node(node, target)
           when :===
             lhs, _method, rhs = *node
             lhs if rhs == target
@@ -167,7 +172,17 @@ module RuboCop
           end
         end
         # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/AbcSize
+
+        def condition_from_equality_node(node, target)
+          lhs, _method, rhs = *node
+          condition = condition_from_binary_op(lhs, rhs, target)
+          condition if condition && !class_reference?(condition)
+        end
+
+        def condition_from_match_node(node, target)
+          lhs, _method, rhs = *node
+          condition_from_binary_op(lhs, rhs, target)
+        end
 
         def condition_from_binary_op(lhs, rhs, target)
           lhs = deparenthesize(lhs)
@@ -199,6 +214,10 @@ module RuboCop
             name == name.upcase
         end
 
+        def class_reference?(node)
+          node.const_type? && node.children[1].match?(/[[:lower:]]/)
+        end
+
         def deparenthesize(node)
           node = node.children.last while node.begin_type?
           node