rubocop 0.51.0 → 0.87.0

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

@@ -10,21 +10,21 @@ 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 ' \
-              'number of times.'.freeze
+              'number of times.'
 
         def on_block(node)
           return unless offending_each_range(node)
@@ -36,20 +36,20 @@ 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,
                               "#{max - min}.times")
           end
         end
 
-        def_node_matcher :offending_each_range, <<-PATTERN
+        private
+
+        def_node_matcher :offending_each_range, <<~PATTERN
           (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN
       end

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

@@ -17,10 +17,12 @@ 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
+        include RangeHelp
+
+        MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        def_node_matcher :each_with_object_candidate?, <<-PATTERN
+        def_node_matcher :each_with_object_candidate?, <<~PATTERN
           (block $(send _ {:inject :reduce} _) $_ $_)
         PATTERN
 
@@ -35,12 +37,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|
@@ -48,18 +48,24 @@ module RuboCop
 
             first_arg, second_arg = *node.arguments
 
-            corrector.replace(first_arg.loc.expression, second_arg.source)
-            corrector.replace(second_arg.loc.expression, first_arg.source)
+            corrector.replace(first_arg, second_arg.source)
+            corrector.replace(second_arg, first_arg.source)
 
             return_value = return_value(node.body)
 
-            corrector.remove(return_value.loc.expression)
+            if return_value_occupies_whole_line?(return_value)
+              corrector.remove(whole_line_expression(return_value))
+            else
+              corrector.remove(return_value)
+            end
           end
         end
-        # rubocop:endable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize
+
+        private
 
         def simple_method_arg?(method_arg)
-          method_arg && method_arg.basic_literal?
+          method_arg&.basic_literal?
         end
 
         # if the accumulator parameter is assigned to in the block,
@@ -80,7 +86,7 @@ module RuboCop
           return unless body
 
           return_value = body.begin_type? ? body.children.last : body
-          return_value if return_value && return_value.lvar_type?
+          return_value if return_value&.lvar_type?
         end
 
         def first_argument_returned?(args, return_value)
@@ -90,6 +96,14 @@ module RuboCop
 
           accumulator_var == return_var
         end
+
+        def return_value_occupies_whole_line?(node)
+          whole_line_expression(node).source.strip == node.source
+        end
+
+        def whole_line_expression(node)
+          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+        end
       end
     end
   end

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

@@ -0,0 +1,48 @@
+# 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
+        include RangeHelp
+
+        MSG = 'Omit pipes for the empty block parameters.'
+
+        def on_block(node)
+          send_node = node.send_node
+          check(node) unless send_node.send_type? && send_node.lambda_literal?
+        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

@@ -36,17 +36,27 @@ module RuboCop
       #     puts 'more'
       #   end
       class EmptyCaseCondition < Cop
+        include RangeHelp
+
         MSG = 'Do not use empty `case` condition, instead use an `if` '\
-              'expression.'.freeze
+              'expression.'
 
         def on_case(case_node)
           return if case_node.condition
 
+          branch_bodies = [
+            *case_node.when_branches.map(&:body),
+            case_node.else_branch
+          ].compact
+
+          return if branch_bodies.any? do |body|
+            body.return_type? ||
+            body.each_descendant.any?(&:return_type?)
+          end
+
           add_offense(case_node, location: :keyword)
         end
 
-        private
-
         def autocorrect(case_node)
           when_branches = case_node.when_branches
 
@@ -56,11 +66,15 @@ 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)
 
           corrector.replace(case_range, 'if')
 
+          keep_first_when_comment(case_node, when_nodes.first, corrector)
+
           when_nodes[1..-1].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
           end
@@ -72,12 +86,23 @@ module RuboCop
 
             next unless conditions.size > 1
 
-            range = range_between(conditions.first.loc.expression.begin_pos,
-                                  conditions.last.loc.expression.end_pos)
+            range = range_between(conditions.first.source_range.begin_pos,
+                                  conditions.last.source_range.end_pos)
 
             corrector.replace(range, conditions.map(&:source).join(' || '))
           end
         end
+
+        def keep_first_when_comment(case_node, first_when_node, corrector)
+          comment = processed_source.comments_before_line(
+            first_when_node.loc.keyword.line
+          ).map(&:text).join("\n")
+
+          line = range_by_whole_lines(case_node.source_range)
+
+          corrector.insert_before(line, "#{comment}\n") if !comment.empty? &&
+                                                           !case_node.parent
+        end
       end
     end
   end

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,11 +77,24 @@ module RuboCop
       #     statement
       #   else
       #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
       class EmptyElse < Cop
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG = 'Redundant `else`-clause.'.freeze
+        MSG = 'Redundant `else`-clause.'
 
         def on_normal_if_unless(node)
           check(node)
@@ -83,6 +104,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_node(node).loc.end.begin_pos
+            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
+          end
+        end
+
         private
 
         def check(node)
@@ -105,24 +136,29 @@ module RuboCop
         end
 
         def nil_check(node)
-          return unless node.else_branch && node.else_branch.nil_type?
+          return unless node.else_branch&.nil_type?
 
           add_offense(node, location: :else)
         end
 
-        def autocorrect(node)
-          return false if autocorrect_forbidden?(node.type.to_s)
+        def comment_in_else?(node)
+          range = else_line_range(node.loc)
+          processed_source.find_comment { |c| range.include?(c.loc.line) }
+        end
 
-          lambda do |corrector|
-            end_pos = base_if_node(node).loc.end.begin_pos
+        def else_line_range(loc)
+          return 0..0 if loc.else.nil? || loc.end.nil?
 
-            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
-          end
+          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
+        def base_node(node)
+          return node if node.case_type?
+          return node unless node.elsif?
+
+          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
+            parent.loc.end
+          end
         end
 
         def autocorrect_forbidden?(type)

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses for empty lambda parameters. Parentheses
+      # for empty lambda parameters do not cause syntax errors, but they are
+      # redundant.
+      #
+      # @example
+      #   # bad
+      #   -> () { do_something }
+      #
+      #   # good
+      #   -> { do_something }
+      #
+      #   # good
+      #   -> (arg) { do_something(arg) }
+      class EmptyLambdaParameter < Cop
+        include EmptyParameter
+        include RangeHelp
+
+        MSG = 'Omit parentheses for the empty lambda parameters.'
+
+        def on_block(node)
+          send_node = node.send_node
+          return unless send_node.send_type?
+
+          check(node) if node.send_node.lambda_literal?
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            send_node = node.parent.send_node
+            range = range_between(
+              send_node.loc.expression.end_pos,
+              node.loc.expression.end_pos
+            )
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,21 +4,34 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for the use of a method, the result of which
-      # would be a literal, like an empty array, hash or string.
+      # would be a literal, like an empty array, hash, or string.
+      #
+      # @example
+      #   # bad
+      #   a = Array.new
+      #   h = Hash.new
+      #   s = String.new
+      #
+      #   # good
+      #   a = []
+      #   h = {}
+      #   s = ''
       class EmptyLiteral < Cop
         include FrozenStringLiteral
+        include RangeHelp
 
-        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'.freeze
-        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
-        STR_MSG = 'Use string literal `%s` instead of `String.new`.'.freeze
+        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
+        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
+        STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
+                  '`String.new`.'
 
-        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
-        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
-        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+        def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
         def_node_matcher :array_with_block,
-                         '(block (send (const nil? :Array) :new) args _)'
+                         '(block (send (const {nil? cbase} :Array) :new) args _)'
         def_node_matcher :hash_with_block,
-                         '(block (send (const nil? :Hash) :new) args _)'
+                         '(block (send (const {nil? cbase} :Hash) :new) args _)'
 
         def on_send(node)
           add_offense(node, message: ARR_MSG)  if offense_array_node?(node)
@@ -28,7 +41,8 @@ module RuboCop
             return if frozen_string_literals_enabled?
 
             add_offense(node,
-                        message: format(STR_MSG, preferred_string_literal))
+                        message: format(STR_MSG,
+                                        prefer: preferred_string_literal))
           end
         end
 
@@ -53,10 +67,11 @@ module RuboCop
         end
 
         def first_argument_unparenthesized?(node)
-          return false unless node.parent && node.parent.send_type?
+          parent = node.parent
+          return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          _receiver, _method_name, *args = *node.parent
-          node.object_id == args.first.object_id && !parentheses?(node.parent)
+          node.object_id == parent.arguments.first.object_id &&
+            !parentheses?(node.parent)
         end
 
         def replacement_range(node)
@@ -65,11 +80,10 @@ module RuboCop
             # `some_method {}` is not same as `some_method Hash.new`
             # because the braces are interpreted as a block. We will have
             # to rewrite the arguments to wrap them in parenthesis.
-            _receiver, _method_name, *args = *node.parent
+            args = node.parent.arguments
 
-            Parser::Source::Range.new(node.parent.loc.expression,
-                                      args[0].loc.expression.begin_pos - 1,
-                                      args[-1].loc.expression.end_pos)
+            range_between(args[0].source_range.begin_pos - 1,
+                          args[-1].source_range.end_pos)
           else
             node.source_range
           end
@@ -94,7 +108,7 @@ module RuboCop
               # `some_method {}` is not same as `some_method Hash.new`
               # because the braces are interpreted as a block. We will have
               # to rewrite the arguments to wrap them in parenthesis.
-              _receiver, _method_name, *args = *node.parent
+              args = node.parent.arguments
               "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
             else
               '{}'

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

@@ -8,13 +8,10 @@ module RuboCop
       # line (compact style), but it can be configured to enforce the `end`
       # to go on its own line (expanded style).
       #
-      # Note: A method definition is not considered empty if it contains
+      # NOTE: A method definition is not considered empty if it contains
       #       comments.
       #
-      # @example
-      #
-      #   # EnforcedStyle: compact (default)
-      #
+      # @example EnforcedStyle: compact (default)
       #   # bad
       #   def foo(bar)
       #   end
@@ -31,10 +28,7 @@ module RuboCop
       #
       #   def self.foo(bar); end
       #
-      # @example
-      #
-      #   # EnforcedStyle: expanded
-      #
+      # @example EnforcedStyle: expanded
       #   # bad
       #   def foo(bar); end
       #
@@ -49,9 +43,9 @@ module RuboCop
       class EmptyMethod < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
+        MSG_COMPACT = 'Put empty method definitions on a single line.'
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
-                       'next line.'.freeze
+                       'next line.'
 
         def on_def(node)
           return if node.body || comment_lines?(node)
@@ -61,14 +55,14 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, corrected(node))
+            corrector.replace(node, corrected(node))
           end
         end
 
+        private
+
         def message(_node)
           compact_style? ? MSG_COMPACT : MSG_EXPANDED
         end
@@ -79,10 +73,13 @@ module RuboCop
         end
 
         def corrected(node)
-          arguments = node.arguments? ? node.arguments.source : ''
-          scope     = node.receiver ? "#{node.receiver.source}." : ''
+          if node.arguments?
+            arguments   = node.arguments.source
+            extra_space = ' ' unless parentheses?(node.arguments)
+          end
+          scope = node.receiver ? "#{node.receiver.source}." : ''
 
-          signature = [scope, node.method_name, arguments].join
+          signature = [scope, node.method_name, extra_space, arguments].join
 
           ["def #{signature}", 'end'].join(joint(node))
         end
@@ -93,10 +90,6 @@ module RuboCop
           compact_style? ? '; ' : "\n#{indent}"
         end
 
-        def comment_lines?(node)
-          processed_source[line_range(node)].any? { |line| comment_line?(line) }
-        end
-
         def compact?(node)
           node.single_line?
         end

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

@@ -4,10 +4,17 @@ module RuboCop
   module Cop
     module Style
       # This cop checks ensures source files have no utf-8 encoding comments.
+      # @example
+      #   # bad
+      #   # encoding: UTF-8
+      #   # coding: UTF-8
+      #   # -*- coding: UTF-8 -*-
       class Encoding < Cop
-        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
-        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
-        SHEBANG = '#!'.freeze
+        include RangeHelp
+
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        SHEBANG = '#!'
 
         def investigate(processed_source)
           return if processed_source.buffer.source.empty?
@@ -21,7 +28,8 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(range, :right))
+            corrector.remove(range_with_surrounding_space(range: range,
+                                                          side: :right))
           end
         end
 
@@ -34,7 +42,7 @@ module RuboCop
         end
 
         def encoding_omitable?(line)
-          line =~ ENCODING_PATTERN
+          ENCODING_PATTERN.match?(line)
         end
 
         def encoding_line_number(processed_source)