rubocop 0.51.0 → 0.52.0

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

@@ -10,18 +10,18 @@ module RuboCop
       #   # bad
       #   class SomeClass
       #     def SomeClass.class_method
-      #       ...
+      #       # ...
       #     end
       #   end
       #
       #   # good
       #   class SomeClass
       #     def self.class_method
-      #       ...
+      #       # ...
       #     end
       #   end
       class ClassMethods < Cop
-        MSG = 'Use `self.%s` instead of `%s.%s`.'.freeze
+        MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'.freeze
 
         def on_class(node)
           name, _superclass, body = *node
@@ -33,6 +33,10 @@ module RuboCop
           check(name, body)
         end
 
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+        end
+
         private
 
         def check(name, node)
@@ -56,11 +60,7 @@ module RuboCop
         end
 
         def message(class_name, method_name)
-          format(MSG, method_name, class_name, method_name)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+          format(MSG, method: method_name, class: class_name)
         end
       end
     end

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

@@ -5,9 +5,10 @@ module RuboCop
     module Style
       # This cop checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
-      # reduced the number of offenses that would be reported.
+      # reduce the number of offenses that would be reported.
       class ClassVars < Cop
-        MSG = 'Replace class var %s with a class instance var.'.freeze
+        MSG = 'Replace class var %<class_var>s with a class ' \
+              'instance var.'.freeze
 
         def on_cvasgn(node)
           add_offense(node, location: :name)
@@ -15,7 +16,7 @@ module RuboCop
 
         def message(node)
           class_var, = *node
-          format(MSG, class_var)
+          format(MSG, class_var: class_var)
         end
       end
     end

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

@@ -12,7 +12,7 @@ module RuboCop
       class CollectionMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'.freeze
 
         def on_block(node)
           check_method_node(node.send_node)
@@ -35,7 +35,9 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, preferred_method(node.method_name), node.method_name)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
         end
 
         def check_method_node(node)

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

@@ -5,6 +5,18 @@ module RuboCop
     module Style
       # This cop checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      #
+      # @example
+      #   # bad
+      #   Timeout::timeout(500) { do_something }
+      #   FileUtils::rmdir(dir)
+      #   Marshal::dump(obj)
+      #
+      #   # good
+      #   Timeout.timeout(500) { do_something }
+      #   FileUtils.rmdir(dir)
+      #   Marshal.dump(obj)
+      #
       class ColonMethodCall < Cop
         MSG = 'Do not use `::` for method calls.'.freeze
 
@@ -14,6 +26,10 @@ module RuboCop
             {:boolean :byte :char :double :float :int :long :short})
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [RedundantSelf]
+        end
+
         def on_send(node)
           # ignore Java interop code like Java::int
           return if java_type_node?(node)

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for class methods that are defined using the `::`
+      # operator instead of the `.` operator.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     def self::bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.bar
+      #     end
+      #   end
+      #
+      class ColonMethodDefinition < Cop
+        MSG = 'Do not use `::` for defining class methods.'.freeze
+
+        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, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -5,26 +5,75 @@ module RuboCop
     module Style
       # This cop enforces using `` or %x around command literals.
       #
-      # @example
-      #   # Good if EnforcedStyle is backticks or mixed, bad if percent_x.
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # good
       #   folders = `find . -type d`.split
       #
-      #   # Good if EnforcedStyle is percent_x, bad if backticks or mixed.
+      #   # good
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
       #   folders = %x(find . -type d).split
       #
-      #   # Good if EnforcedStyle is backticks, bad if percent_x or mixed.
+      #   # bad
       #   `
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   `
       #
-      #   # Good if EnforcedStyle is percent_x or mixed, bad if backticks.
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
       #   %x(
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   )
       #
-      #   # Bad unless AllowInnerBackticks is true.
+      # @example EnforcedStyle: percent_x
+      #   # bad
+      #   folders = `find . -type d`.split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = %x(find . -type d).split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example AllowInnerBackticks: false (default)
+      #   # If `false`, the cop will always recommend using `%x` if one or more
+      #   # backticks are found in the command string.
+      #
+      #   # bad
+      #   `echo \`ls\``
+      #
+      #   # good
+      #   %x(echo `ls`)
+      #
+      # @example AllowInnerBackticks: true
+      #   # good
       #   `echo \`ls\``
       class CommandLiteral < Cop
         include ConfigurableEnforcedStyle
@@ -42,6 +91,21 @@ module RuboCop
           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)
+          end
+        end
+
         private
 
         def check_backtick_literal(node)
@@ -109,21 +173,6 @@ module RuboCop
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%x'].split(//)
         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)
-          end
-        end
       end
     end
   end

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

@@ -5,13 +5,38 @@ module RuboCop
     module Style
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
+      #
+      # @example
+      #   # bad
+      #   # TODO make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # TODO:make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # fixme: does not work
+      #
+      #   # good
+      #   # FIXME: does not work
+      #
+      #   # bad
+      #   # Optimize does not work
+      #
+      #   # good
+      #   # OPTIMIZE: does not work
       class CommentAnnotation < Cop
         include AnnotationComment
 
-        MSG = 'Annotation keywords like `%s` should be all upper case, ' \
-              'followed by a colon, and a space, ' \
+        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
-        MISSING_NOTE = 'Annotation comment, with keyword `%s`, ' \
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
                        'is missing a note.'.freeze
 
         def investigate(processed_source)
@@ -26,17 +51,11 @@ module RuboCop
             add_offense(
               comment,
               location: annotation_range(comment, margin, length),
-              message: format(note ? MSG : MISSING_NOTE, first_word)
+              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
             )
           end
         end
 
-        private
-
-        def first_comment_line?(comments, ix)
-          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
-        end
-
         def autocorrect(comment)
           margin, first_word, colon, space, note = split_comment(comment)
           return if note.nil?
@@ -47,6 +66,12 @@ module RuboCop
           ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
         end
 
+        private
+
+        def first_comment_line?(comments, ix)
+          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
+        end
+
         def annotation_range(comment, margin, length)
           start = comment.loc.expression.begin_pos + margin.length
           range_between(start, start + length)

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

@@ -29,23 +29,25 @@ module RuboCop
       #   end
       #
       #   # good
-      #   class x # :nodoc:
+      #   class X # :nodoc:
       #     y
       #   end
       class CommentedKeyword < Cop
         MSG = 'Do not place comments on the same line as the ' \
-              '`%s` keyword.'.freeze
+              '`%<keyword>s` keyword.'.freeze
 
         def investigate(processed_source)
           heredoc_lines = extract_heredoc_lines(processed_source.ast)
 
-          processed_source.lines.each_with_index do |line, index|
-            next if heredoc_lines.any? { |r| r.include?(index + 1) }
+          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,
-                                 index + 1,
-                                 (line.index('#'))...(line.length))
+                                 line_position,
+                                 (location.column)...(location.last_column))
 
             add_offense(range, location: range)
           end
@@ -57,14 +59,15 @@ module RuboCop
         ALLOWED_COMMENTS = %w[:nodoc: rubocop:disable].freeze
 
         def offensive?(line)
-          KEYWORDS.any? { |k| line =~ /^\s*#{k}\s+.*#/ } &&
+          line = line.lstrip
+          line.start_with?(*KEYWORDS) &&
             ALLOWED_COMMENTS.none? { |c| line =~ /#\s*#{c}/ }
         end
 
         def message(node)
           line = node.source_line
           keyword = /^\s*(\S+).*#/.match(line)[1]
-          format(MSG, keyword)
+          format(MSG, keyword: keyword)
         end
 
         def extract_heredoc_lines(ast)

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

@@ -108,9 +108,7 @@ module RuboCop
       # assignment to the same variable when using the return of the
       # condition can be used instead.
       #
-      # @example
-      #   EnforcedStyle: assign_to_condition
-      #
+      # @example EnforcedStyle: assign_to_condition (default)
       #   # bad
       #   if foo
       #     bar = 1
@@ -155,7 +153,7 @@ module RuboCop
       #            2
       #          end
       #
-      #   EnforcedStyle: assign_inside_condition
+      # @example EnforcedStyle: assign_inside_condition
       #   # bad
       #   bar = if foo
       #           1
@@ -268,6 +266,14 @@ module RuboCop
           check_node(node, branches)
         end
 
+        def autocorrect(node)
+          if assignment_type?(node)
+            move_assignment_inside_condition(node)
+          else
+            move_assignment_outside_condition(node)
+          end
+        end
+
         private
 
         def check_assignment_to_condition(node)
@@ -300,14 +306,6 @@ module RuboCop
           single_line_conditions_only? && branches.any?(&:begin_type?)
         end
 
-        def autocorrect(node)
-          if assignment_type?(node)
-            move_assignment_inside_condition(node)
-          else
-            move_assignment_outside_condition(node)
-          end
-        end
-
         def assignment_node(node)
           *_variable, assignment = *node