rubocop 0.51.0 → 0.52.0

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

@@ -16,7 +16,7 @@ module RuboCop
       # an offense is reported.
       #
       class Copyright < Cop
-        MSG = 'Include a copyright notice matching /%s/ before ' \
+        MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
               'any code.'.freeze
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
                                     'your RuboCop config'.freeze
@@ -26,7 +26,21 @@ module RuboCop
           return if notice_found?(processed_source)
           range = source_range(processed_source.buffer, 1, 0)
           add_offense(insert_notice_before(processed_source),
-                      location: range, message: MSG % notice)
+                      location: range, message: format(MSG, notice: notice))
+        end
+
+        def autocorrect(token)
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          regex = Regexp.new(notice)
+          unless autocorrect_notice =~ regex
+            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                           "match Notice /#{notice}/"
+          end
+
+          lambda do |corrector|
+            range = token.nil? ? range_between(0, 0) : token.pos
+            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          end
         end
 
         private
@@ -49,40 +63,25 @@ module RuboCop
         def shebang_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
           token = processed_source.tokens[token_index]
-          token.type == :tCOMMENT && token.text =~ /^#!.*$/
+          token.comment? && token.text =~ /^#!.*$/
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
           token = processed_source.tokens[token_index]
-          token.type == :tCOMMENT &&
-            token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+          token.comment? && token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
         end
 
         def notice_found?(processed_source)
           notice_found = false
           notice_regexp = Regexp.new(notice)
           processed_source.tokens.each do |token|
-            break unless token.type == :tCOMMENT
+            break unless token.comment?
             notice_found = !(token.text =~ notice_regexp).nil?
             break if notice_found
           end
           notice_found
         end
-
-        def autocorrect(token)
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
-          regex = Regexp.new(notice)
-          unless autocorrect_notice =~ regex
-            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                           "match Notice /#{notice}/"
-          end
-
-          lambda do |corrector|
-            range = token.nil? ? range_between(0, 0) : token.pos
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
-          end
-        end
       end
     end
   end

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

@@ -26,11 +26,11 @@ module RuboCop
         MSG = 'Prefer Date or Time over DateTime.'.freeze
 
         def_node_matcher :date_time?, <<-PATTERN
-          (send (const _ :DateTime) ...)
+          (send (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
         def_node_matcher :historic_date?, <<-PATTERN
-          (send _ _ _ (const (const _ :Date) _))
+          (send _ _ _ (const (const nil? :Date) _))
         PATTERN
 
         def on_send(node)

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

@@ -6,6 +6,33 @@ module RuboCop
       # This cop checks for parentheses in the definition of a method,
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     # does a thing
+      #   end
+      #
+      #   # also good
+      #   def foo() does_a_thing end
+      #
+      # @example
+      #
+      #   # bad
+      #   def Baz.foo()
+      #     # does a thing
+      #   end
+      #
+      #   # good
+      #   def Baz.foo
+      #     # does a thing
+      #   end
       class DefWithParentheses < Cop
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'.freeze
@@ -18,8 +45,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(node.loc.begin)

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

@@ -31,14 +31,14 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, '__dir__')
           end
         end
 
+        private
+
         def file_keyword?(node)
           node.str_type? && node.source_range.is?('__FILE__')
         end

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

@@ -11,10 +11,23 @@ module RuboCop
       # The documentation requirement is annulled if the class or module has
       # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
       # same for all its children.
+      #
+      # @example
+      #   # bad
+      #   class Person
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # Description/Explanation of Person class
+      #   class Person
+      #     # ...
+      #   end
+      #
       class Documentation < Cop
         include DocumentationComment
 
-        MSG = 'Missing top-level %s documentation comment.'.freeze
+        MSG = 'Missing top-level %<type>s documentation comment.'.freeze
 
         def_node_matcher :constant_definition?, '{class module casgn}'
 
@@ -38,7 +51,9 @@ module RuboCop
           return if namespace?(body)
           return if documentation_comment?(node) || nodoc_comment?(node)
 
-          add_offense(node, location: :keyword, message: format(MSG, type))
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, type: type))
         end
 
         def namespace?(node)

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

@@ -10,17 +10,17 @@ module RuboCop
       # This check only applies if the block takes no parameters.
       #
       # @example
-      #   @bad
+      #   # bad
       #   (1..5).each { }
       #
-      #   @good
+      #   # good
       #   5.times { }
       #
       # @example
-      #   @bad
+      #   # bad
       #   (0...10).each {}
       #
-      #   @good
+      #   # good
       #   10.times {}
       class EachForSimpleLoop < Cop
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
@@ -36,19 +36,19 @@ module RuboCop
           add_offense(node, location: range)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             range_type, min, max = offending_each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.children.first.source_range,
+            corrector.replace(node.send_node.source_range,
                               "#{max - min}.times")
           end
         end
 
+        private
+
         def_node_matcher :offending_each_range, <<-PATTERN
           (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN

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

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
       class EachWithObject < Cop
-        MSG = 'Use `each_with_object` instead of `%s`.'.freeze
+        MSG = 'Use `each_with_object` instead of `%<method>s`.'.freeze
         METHODS = %i[inject reduce].freeze
 
         def_node_matcher :each_with_object_candidate?, <<-PATTERN
@@ -35,12 +35,10 @@ module RuboCop
             return if accumulator_param_assigned_to?(body, args)
 
             add_offense(node, location: method.loc.selector,
-                              message: format(MSG, method_name))
+                              message: format(MSG, method: method_name))
           end
         end
 
-        private
-
         # rubocop:disable Metrics/AbcSize
         def autocorrect(node)
           lambda do |corrector|
@@ -56,7 +54,9 @@ module RuboCop
             corrector.remove(return_value.loc.expression)
           end
         end
-        # rubocop:endable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize
+
+        private
 
         def simple_method_arg?(method_arg)
           method_arg && method_arg.basic_literal?

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for pipes for empty block parameters. Pipes for empty
+      # block parameters do not cause syntax errors, but they are redundant.
+      #
+      # @example
+      #   # bad
+      #   a do ||
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   a { || do_something }
+      #
+      #   # good
+      #   a do
+      #   end
+      #
+      #   # good
+      #   a { do_something }
+      class EmptyBlockParameter < Cop
+        include EmptyParameter
+
+        MSG = 'Omit pipes for the empty block parameters.'.freeze
+
+        def on_block(node)
+          send_node = node.send_node
+          check(node) unless send_node.send_type? && send_node.stabby_lambda?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            block = node.parent
+            range = range_between(
+              block.loc.begin.end_pos,
+              node.loc.expression.end_pos
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -45,8 +45,6 @@ module RuboCop
           add_offense(case_node, location: :keyword)
         end
 
-        private
-
         def autocorrect(case_node)
           when_branches = case_node.when_branches
 
@@ -56,6 +54,8 @@ module RuboCop
           end
         end
 
+        private
+
         def correct_case_when(corrector, case_node, when_nodes)
           case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
 

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

@@ -6,56 +6,64 @@ module RuboCop
       # Checks for empty else-clauses, possibly including comments and/or an
       # explicit `nil` depending on the EnforcedStyle.
       #
-      # SupportedStyles:
+      # @example EnforcedStyle: empty
+      #   # warn only on empty else
       #
-      # @example
-      #   # good for all styles
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
       #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # good
       #   if condition
       #     statement
       #   else
       #     statement
       #   end
       #
-      #   # good for all styles
+      #   # good
       #   if condition
       #     statement
       #   end
       #
-      # @example
-      #   # empty - warn only on empty else
+      # @example EnforcedStyle: nil
+      #   # warn on else with nil in it
       #
       #   # bad
       #   if condition
       #     statement
       #   else
+      #     nil
       #   end
       #
       #   # good
       #   if condition
       #     statement
       #   else
-      #     nil
       #   end
       #
-      # @example
-      #   # nil - warn on else with nil in it
-      #
-      #   # bad
+      #   # good
       #   if condition
       #     statement
       #   else
-      #     nil
+      #     statement
       #   end
       #
       #   # good
       #   if condition
       #     statement
-      #   else
       #   end
       #
-      # @example
-      #   # both - warn on empty else and else with nil in it
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
       #
       #   # bad
       #   if condition
@@ -69,6 +77,18 @@ module RuboCop
       #     statement
       #   else
       #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
       class EmptyElse < Cop
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
@@ -83,6 +103,16 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+          return false if comment_in_else?(node)
+
+          lambda do |corrector|
+            end_pos = base_if_node(node).loc.end.begin_pos
+            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
+          end
+        end
+
         private
 
         def check(node)
@@ -110,14 +140,14 @@ module RuboCop
           add_offense(node, location: :else)
         end
 
-        def autocorrect(node)
-          return false if autocorrect_forbidden?(node.type.to_s)
-
-          lambda do |corrector|
-            end_pos = base_if_node(node).loc.end.begin_pos
+        def comment_in_else?(node)
+          range = else_line_range(node.loc)
+          processed_source.comments.find { |c| range.include?(c.loc.line) }
+        end
 
-            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
-          end
+        def else_line_range(loc)
+          return 0..0 if loc.else.nil? || loc.end.nil?
+          loc.else.first_line..loc.end.first_line
         end
 
         def base_if_node(node)