rubocop 0.52.1 → 0.93.1

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

@@ -17,13 +17,14 @@ module RuboCop
       #   FileUtils.rmdir(dir)
       #   Marshal.dump(obj)
       #
-      class ColonMethodCall < Cop
-        MSG = 'Do not use `::` for method calls.'.freeze
+      class ColonMethodCall < Base
+        extend AutoCorrector
 
-        def_node_matcher :java_type_node?, <<-PATTERN
+        MSG = 'Do not use `::` for method calls.'
+
+        def_node_matcher :java_type_node?, <<~PATTERN
           (send
-            (const nil? :Java)
-            {:boolean :byte :char :double :float :int :long :short})
+            (const nil? :Java) _)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -31,17 +32,14 @@ module RuboCop
         end
 
         def on_send(node)
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
-
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
+          # ignore Java interop code like Java::int
+          return if java_type_node?(node)
 
-          add_offense(node, location: :dot)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+          add_offense(node.loc.dot) do |corrector|
+            corrector.replace(node.loc.dot, '.')
+          end
         end
       end
     end

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

@@ -19,16 +19,17 @@ module RuboCop
       #     end
       #   end
       #
-      class ColonMethodDefinition < Cop
-        MSG = 'Do not use `::` for defining class methods.'.freeze
+      class ColonMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Do not use `::` for defining class methods.'
 
         def on_defs(node)
           return unless node.loc.operator.source == '::'
-          add_offense(node, location: :operator)
-        end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.operator, '.') }
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '.')
+          end
         end
       end
     end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where multiple consecutive loops over the same data
+      # can be combined into a single loop. It is very likely that combining them
+      # will make the code more efficient and more concise.
+      #
+      # It is marked as unsafe, because the first loop might modify
+      # a state that the second loop depends on; these two aren't combinable.
+      #
+      # @example
+      #   # bad
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #     end
+      #
+      #     items.each do |item|
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #     end
+      #
+      #     for item in items do
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     each_slice(2) { |slice| do_something(slice) }
+      #     each_slice(3) { |slice| do_something(slice) }
+      #   end
+      #
+      class CombinableLoops < Base
+        MSG = 'Combine this loop with the previous loop.'
+
+        def on_block(node)
+          return unless node.parent&.begin_type?
+          return unless collection_looping_method?(node)
+
+          add_offense(node) if same_collection_looping?(node, node.left_sibling)
+        end
+
+        def on_for(node)
+          return unless node.parent&.begin_type?
+
+          sibling = node.left_sibling
+          add_offense(node) if sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        private
+
+        def collection_looping_method?(node)
+          method_name = node.send_node.method_name
+          method_name.match?(/^each/) || method_name.match?(/_each$/)
+        end
+
+        def same_collection_looping?(node, sibling)
+          sibling&.block_type? &&
+            sibling.send_node.method?(node.method_name) &&
+            sibling.send_node.receiver == node.send_node.receiver &&
+            sibling.send_node.arguments == node.send_node.arguments
+        end
+      end
+    end
+  end
+end

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

@@ -75,53 +75,52 @@ module RuboCop
       # @example AllowInnerBackticks: true
       #   # good
       #   `echo \`ls\``
-      class CommandLiteral < Cop
+      class CommandLiteral < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG_USE_BACKTICKS = 'Use backticks around command string.'.freeze
-        MSG_USE_PERCENT_X = 'Use `%x` around command string.'.freeze
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
 
         def on_xstr(node)
-          return if heredoc_literal?(node)
+          return if node.heredoc?
 
           if backtick_literal?(node)
-            check_backtick_literal(node)
+            check_backtick_literal(node, MSG_USE_PERCENT_X)
           else
-            check_percent_x_literal(node)
-          end
-        end
-
-        def autocorrect(node)
-          return if contains_backtick?(node)
-
-          replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w[` `]
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
+            check_percent_x_literal(node, MSG_USE_BACKTICKS)
           end
         end
 
         private
 
-        def check_backtick_literal(node)
+        def check_backtick_literal(node, message)
           return if allowed_backtick_literal?(node)
 
-          add_offense(node)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def check_percent_x_literal(node)
+        def check_percent_x_literal(node, message)
           return if allowed_percent_x_literal?(node)
 
-          add_offense(node)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def message(node)
-          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
+        def autocorrect(corrector, node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
         end
 
         def allowed_backtick_literal?(node)
@@ -153,7 +152,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          node_body(node) =~ /`/
+          /`/.match?(node_body(node))
         end
 
         def node_body(node)
@@ -161,17 +160,25 @@ module RuboCop
           loc.expression.source[loc.begin.length...-loc.end.length]
         end
 
-        def heredoc_literal?(node)
-          node.loc.respond_to?(:heredoc_body)
-        end
-
         def backtick_literal?(node)
           node.loc.begin.source == '`'
         end
 
-        def preferred_delimiters
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).split(//)
+        end
+
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
+
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
+
+        def preferred_delimiters_config
           config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%x'].split(//)
+            ['PreferredDelimiters']
         end
       end
     end

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

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
       #
+      # NOTE: With a multiline comment block (where each line is only a
+      # comment), only the first line will be able to register an offense, even
+      # if an annotation keyword starts another line. This is done to prevent
+      # incorrect registering of keywords (eg. `review`) inside a paragraph as an
+      # annotation.
+      #
       # @example
       #   # bad
       #   # TODO make better
@@ -30,50 +36,57 @@ module RuboCop
       #
       #   # good
       #   # OPTIMIZE: does not work
-      class CommentAnnotation < Cop
+      class CommentAnnotation < Base
         include AnnotationComment
+        include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
               'upper case, followed by a colon, and a space, ' \
-              'then a note describing the problem.'.freeze
+              'then a note describing the problem.'
         MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
-                       'is missing a note.'.freeze
+                       'is missing a note.'
 
-        def investigate(processed_source)
-          processed_source.comments.each_with_index do |comment, ix|
-            next unless first_comment_line?(processed_source.comments, ix)
+        def on_new_investigation
+          processed_source.comments.each_with_index do |comment, index|
+            next unless first_comment_line?(processed_source.comments, index) ||
+                        inline_comment?(comment)
 
             margin, first_word, colon, space, note = split_comment(comment)
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            length = concat_length(first_word, colon, space)
-            add_offense(
-              comment,
-              location: annotation_range(comment, margin, length),
-              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
-            )
+            range = annotation_range(comment, margin, first_word, colon, space)
+
+            register_offense(range, note, first_word)
           end
         end
 
-        def autocorrect(comment)
-          margin, first_word, colon, space, note = split_comment(comment)
-          return if note.nil?
+        private
 
-          length = concat_length(first_word, colon, space)
-          range = annotation_range(comment, margin, length)
+        def register_offense(range, note, first_word)
+          add_offense(
+            range,
+            message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
+          ) do |corrector|
+            next if note.nil?
 
-          ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
+            corrector.replace(range, "#{first_word.upcase}: ")
+          end
         end
 
-        private
+        def first_comment_line?(comments, index)
+          index.zero? ||
+            comments[index - 1].loc.line < comments[index].loc.line - 1
+        end
 
-        def first_comment_line?(comments, ix)
-          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
+        def inline_comment?(comment)
+          !comment_line?(comment.loc.expression.source_line)
         end
 
-        def annotation_range(comment, margin, length)
+        def annotation_range(comment, margin, first_word, colon, space)
           start = comment.loc.expression.begin_pos + margin.length
+          length = concat_length(first_word, colon, space)
           range_between(start, start + length)
         end
 

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

@@ -6,8 +6,9 @@ module RuboCop
       # This cop checks for comments put on the same line as some keywords.
       # These keywords are: `begin`, `class`, `def`, `end`, `module`.
       #
-      # Note that some comments (such as `:nodoc:` and `rubocop:disable`) are
-      # allowed.
+      # Note that some comments
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
+      # are allowed.
       #
       # @example
       #   # bad
@@ -32,51 +33,41 @@ module RuboCop
       #   class X # :nodoc:
       #     y
       #   end
-      class CommentedKeyword < Cop
+      class CommentedKeyword < Base
         MSG = 'Do not place comments on the same line as the ' \
-              '`%<keyword>s` keyword.'.freeze
-
-        def investigate(processed_source)
-          heredoc_lines = extract_heredoc_lines(processed_source.ast)
+              '`%<keyword>s` keyword.'
 
+        def on_new_investigation
           processed_source.comments.each do |comment|
-            location = comment.location
-            line_position = location.line
-            line = processed_source.lines[line_position - 1]
-            next if heredoc_lines.any? { |r| r.include?(line_position) }
-            next unless offensive?(line)
-            range = source_range(processed_source.buffer,
-                                 line_position,
-                                 (location.column)...(location.last_column))
+            next unless (match = line(comment).match(/(?<keyword>\S+).*#/))
 
-            add_offense(range, location: range)
+            if offensive?(comment)
+              add_offense(comment, message: format(MSG, keyword: match[:keyword]))
+            end
           end
         end
 
         private
 
         KEYWORDS = %w[begin class def end module].freeze
-        ALLOWED_COMMENTS = %w[:nodoc: rubocop:disable].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
 
-        def offensive?(line)
-          line = line.lstrip
-          KEYWORDS.any? { |word| line =~ /^#{word}\s/ } &&
-            ALLOWED_COMMENTS.none? { |c| line =~ /#\s*#{c}/ }
-        end
+        ALLOWED_COMMENTS = %w[
+          :nodoc:
+          :yields:
+          rubocop:disable
+          rubocop:todo
+        ].freeze
+        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
-        def message(node)
-          line = node.source_line
-          keyword = /^\s*(\S+).*#/.match(line)[1]
-          format(MSG, keyword: keyword)
+        def offensive?(comment)
+          line = line(comment)
+          KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
+            ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
-        def extract_heredoc_lines(ast)
-          return [] unless ast
-          ast.each_node.with_object([]) do |node, heredocs|
-            next unless node.location.is_a?(Parser::Source::Map::Heredoc)
-            body = node.location.heredoc_body
-            heredocs << (body.first_line...body.last_line)
-          end
+        def line(comment)
+          comment.location.expression.source_line
         end
       end
     end