rubocop 0.49.1 → 0.52.0

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

@@ -6,18 +6,44 @@ 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
-        include OnMethodDef
-
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'.freeze
 
-        def on_method_def(node, _method_name, args, _body)
+        def on_def(node)
           return if node.single_line?
-          return unless args.children.empty? && args.loc.begin
+          return unless !node.arguments? && node.arguments.loc.begin
 
-          add_offense(args, :begin)
+          add_offense(node.arguments, location: :begin)
         end
+        alias on_defs on_def
 
         def autocorrect(node)
           lambda do |corrector|

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where the `#__dir__` method can replace more
+      # complex constructs to retrieve a canonicalized absolute path to the
+      # current file.
+      #
+      # @example
+      #   # bad
+      #   path = File.expand_path(File.dirname(__FILE__))
+      #
+      #   # bad
+      #   path = File.dirname(File.realpath(__FILE__))
+      #
+      #   # good
+      #   path = __dir__
+      class Dir < Cop
+        MSG = 'Use `__dir__` to get an absolute path to the current ' \
+              "file's directory.".freeze
+
+        def_node_matcher :dir_replacement?, <<-PATTERN
+          {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
+           (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
+        PATTERN
+
+        def on_send(node)
+          dir_replacement?(node) do
+            add_offense(node)
+          end
+        end
+
+        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
+      end
+    end
+  end
+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, :keyword, format(MSG, type))
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, type: type))
         end
 
         def namespace?(node)

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

@@ -49,7 +49,6 @@ module RuboCop
       #   end
       class DocumentationMethod < Cop
         include DocumentationComment
-        include OnMethodDef
         include DefNode
 
         MSG = 'Missing method documentation comment.'.freeze
@@ -57,10 +56,7 @@ module RuboCop
         def on_def(node)
           check(node)
         end
-
-        def on_method_def(node, *)
-          check(node)
-        end
+        alias on_defs on_def
 
         private
 
@@ -68,7 +64,7 @@ module RuboCop
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
 
-          add_offense(node, :expression, MSG)
+          add_offense(node)
         end
 
         def require_for_non_public_methods?

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

@@ -27,7 +27,7 @@ module RuboCop
         def on_send(node)
           return unless double_negative?(node) && node.keyword_bang?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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 ' \
@@ -33,22 +33,22 @@ module RuboCop
 
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
-          add_offense(node, range)
+          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
@@ -34,12 +34,11 @@ module RuboCop
             return unless first_argument_returned?(args, return_value)
             return if accumulator_param_assigned_to?(body, args)
 
-            add_offense(node, method.loc.selector, format(MSG, method_name))
+            add_offense(node, location: method.loc.selector,
+                              message: format(MSG, method: method_name))
           end
         end
 
-        private
-
         # rubocop:disable Metrics/AbcSize
         def autocorrect(node)
           lambda do |corrector|
@@ -55,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

@@ -42,11 +42,9 @@ module RuboCop
         def on_case(case_node)
           return if case_node.condition
 
-          add_offense(case_node, :keyword, MSG)
+          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)
@@ -101,26 +131,27 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node, :else, MSG)
+          add_offense(node, location: :else)
         end
 
         def nil_check(node)
           return unless node.else_branch && node.else_branch.nil_type?
 
-          add_offense(node, :else, MSG)
+          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)
+          return node unless node.case_type? || node.elsif?
           node.each_ancestor(:if).find { |parent| parent.loc.end } || node
         end