rubocop 0.73.0 → 0.77.0

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

@@ -35,6 +35,18 @@ module RuboCop
       #     end
       #   end
       #
+      # @example AllowMultipleReturnValues: false (default)
+      #   # bad
+      #   def test
+      #     return x, y
+      #   end
+      #
+      # @example AllowMultipleReturnValues: true
+      #   # good
+      #   def test
+      #     return x, y
+      #   end
+      #
       class RedundantReturn < Cop
         include RangeHelp
 
@@ -42,33 +54,42 @@ module RuboCop
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
 
         def on_def(node)
-          return unless node.body
-
           check_branch(node.body)
         end
         alias on_defs on_def
 
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def autocorrect(node)
           lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
             end
-
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless return_value.braces?
-            end
-            return_kw = range_with_surrounding_space(range: node.loc.keyword,
-                                                     side: :right)
-            corrector.remove(return_kw)
           end
         end
 
         private
 
+        def correct_without_arguments(return_node, corrector)
+          corrector.replace(return_node.source_range, 'nil')
+        end
+
+        def correct_with_arguments(return_node, corrector)
+          if return_node.arguments.size > 1
+            add_brackets(corrector, return_node)
+          elsif hash_without_braces?(return_node.first_argument)
+            add_braces(corrector, return_node.first_argument)
+          end
+
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
+                                                 side: :right)
+          corrector.remove(keyword)
+        end
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
         def add_brackets(corrector, node)
           kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '[')
@@ -81,13 +102,6 @@ module RuboCop
           corrector.insert_after(kids.last, '}')
         end
 
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
-
-          !args.first.begin_type? || !args.first.children.empty?
-        end
-
         # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
@@ -136,12 +150,8 @@ module RuboCop
         end
 
         def check_begin_node(node)
-          expressions = *node
-          last_expr = expressions.last
-
-          return unless last_expr&.return_type?
-
-          check_return_node(last_expr)
+          last_expr = node.children.last
+          check_branch(last_expr)
         end
 
         def allow_multiple_return_values?

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

@@ -83,9 +83,16 @@ module RuboCop
           on_argument(node)
         end
 
+        def on_masgn(node)
+          lhs, rhs = *node
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
         def on_lvasgn(node)
           lhs, rhs = *node
-          @local_variables_scopes[rhs] << lhs
+          add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
         def on_send(node)
@@ -148,6 +155,16 @@ module RuboCop
 
           @allowed_send_nodes << node
         end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each do |argument|
+              @local_variables_scopes[argument] << lhs
+            end
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/{unneeded_sort.rb → redundant_sort.rb}

@@ -49,13 +49,13 @@ module RuboCop
       #   # good
       #   arr.max_by(&:foo)
       #
-      class UnneededSort < Cop
+      class RedundantSort < Cop
         include RangeHelp
 
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
-        def_node_matcher :unneeded_sort?, <<~MATCHER
+        def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
             (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
@@ -72,7 +72,7 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          unneeded_sort?(node) do |sort_node, sorter, accessor|
+          redundant_sort?(node) do |sort_node, sorter, accessor|
             range = range_between(
               sort_node.loc.selector.begin_pos,
               node.loc.expression.end_pos
@@ -87,7 +87,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          sort_node, sorter, accessor = unneeded_sort?(node)
+          sort_node, sorter, accessor = redundant_sort?(node)
 
           lambda do |corrector|
             # Remove accessor, e.g. `first` or `[-1]`.
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def base(accessor, arg)
-          if accessor == :first || (arg&.zero?)
+          if accessor == :first || arg&.zero?
             'min'
           elsif accessor == :last || arg == -1
             'max'

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

@@ -5,16 +5,40 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       #
+      # The cop to check `rescue` in its modifier form is added for following
+      # reasons:
+      #
+      # * The syntax of modifier form `rescue` can be misleading because it
+      #   might led us to believe that `rescue` handles the given exception
+      #   but it actually rescue all exceptions to return the given rescue
+      #   block. In this case, value returned by handle_error or
+      #   SomeException.
+      #
+      # * Modifier form `rescue` would rescue all the exceptions. It would
+      #   silently skip all exception or errors and handle the error.
+      #   Example: If `NoMethodError` is raised, modifier form rescue would
+      #   handle the exception.
+      #
       # @example
       #   # bad
       #   some_method rescue handle_error
       #
+      #   # bad
+      #   some_method rescue SomeException
+      #
       #   # good
       #   begin
       #     some_method
       #   rescue
       #     handle_error
       #   end
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue SomeException
+      #     handle_error
+      #   end
       class RescueModifier < Cop
         include Alignment
         include RescueNode

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

@@ -112,14 +112,14 @@ module RuboCop
         end
 
         def autocorrect(node)
-          _check, body, = node.node_parts
-          _checked_variable, matching_receiver, = extract_parts(node)
-          method_call, = matching_receiver.parent
+          body = node.node_parts[1]
+          method_call = method_call(node)
 
           lambda do |corrector|
             corrector.remove(begin_range(node, body))
             corrector.remove(end_range(node, body))
             corrector.insert_before(method_call.loc.dot, '&')
+            handle_comments(corrector, node, method_call)
 
             add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
           end
@@ -127,10 +127,30 @@ module RuboCop
 
         private
 
+        def handle_comments(corrector, node, method_call)
+          comments = comments(node)
+          return if comments.empty?
+
+          corrector.insert_before(method_call.loc.expression,
+                                  "#{comments.map(&:text).join("\n")}\n")
+        end
+
+        def comments(node)
+          processed_source.comments.select do |comment|
+            comment.loc.first_line > node.loc.first_line &&
+              comment.loc.last_line < node.loc.last_line
+          end
+        end
+
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end
 
+        def method_call(node)
+          _checked_variable, matching_receiver, = extract_parts(node)
+          matching_receiver.parent
+        end
+
         def extract_parts(node)
           case node.type
           when :if

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
       #
+      # This cop has `AllowAsExpressionSeparator` configuration option.
+      # It allows `;` to separate several expressions on the same line.
+      #
       # @example
       #   # bad
       #   foo = 1; bar = 2;
@@ -15,6 +18,14 @@ module RuboCop
       #   foo = 1
       #   bar = 2
       #   baz = 3
+      #
+      # @example AllowAsExpressionSeparator: false (default)
+      #   # bad
+      #   foo = 1; bar = 2
+      #
+      # @example AllowAsExpressionSeparator: true
+      #   # good
+      #   foo = 1; bar = 2
       class Semicolon < Cop
         include RangeHelp
 
@@ -36,8 +47,8 @@ module RuboCop
           return if exprs.size < 2
 
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.source_range.line }
-          lines = exprs_lines.group_by { |i| i }
+          exprs_lines = exprs.map(&:first_line)
+          lines = exprs_lines.group_by(&:itself)
 
           lines.each do |line, expr_on_line|
             # Every line with more than one expression on it is a

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

@@ -13,10 +13,17 @@ module RuboCop
       #   def @table.columns; super; end
       #
       #   # good
-      #   def no_op; end
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
       #
+      # @example AllowIfMethodIsEmpty: true (default)
+      #   # good
+      #   def no_op; end
+      #
+      # @example AllowIfMethodIsEmpty: false
+      #   # bad
+      #   def no_op; end
+      #
       class SingleLineMethods < Cop
         include Alignment
 

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

@@ -160,17 +160,15 @@ module RuboCop
         end
 
         def format_message(english, regular, global)
-          if !regular.empty? && !english.empty?
+          if regular.empty?
+            format(MSG_ENGLISH, prefer: format_list(english), global: global)
+          elsif english.empty?
+            format(MSG_REGULAR, prefer: format_list(regular), global: global)
+          else
             format(MSG_BOTH,
                    prefer: format_list(english),
                    regular: format_list(regular),
                    global: global)
-          elsif !regular.empty?
-            format(MSG_REGULAR, prefer: format_list(regular), global: global)
-          elsif !english.empty?
-            format(MSG_ENGLISH, prefer: format_list(english), global: global)
-          else
-            raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
           end
         end
 

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

@@ -8,6 +8,11 @@ module RuboCop
       # parentheses using `EnforcedStyle`. Omission is only enforced when
       # removing the parentheses won't cause a different behavior.
       #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
       # @example EnforcedStyle: require_no_parentheses (default)
       #   # bad
       #   foo = (bar?) ? a : b
@@ -40,6 +45,15 @@ module RuboCop
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo = (bar = baz) ? a : b
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo = (bar = baz) ? a : b
+      #
       class TernaryParentheses < Cop
         include SafeAssignment
         include ConfigurableEnforcedStyle
@@ -53,11 +67,16 @@ module RuboCop
           ' complex conditions.'
 
         def on_if(node)
+          return if only_closing_parenthesis_is_last_line?(node.condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
           add_offense(node, location: node.source_range)
         end
 
+        def only_closing_parenthesis_is_last_line?(condition)
+          condition.source.split("\n").last == ')'
+        end
+
         def autocorrect(node)
           condition = node.condition
 

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

@@ -42,7 +42,7 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node.to_a.last, location: end_token(node).pos)
+          add_offense(node, location: end_token(node).pos)
         end
 
         def autocorrect(node)
@@ -61,7 +61,7 @@ module RuboCop
         end
 
         def end_token(node)
-          @end_token ||= tokens(node).reverse.find(&:end?)
+          tokens(node).reverse.find(&:end?)
         end
 
         def body_and_end_on_same_line?(node)
@@ -69,10 +69,8 @@ module RuboCop
         end
 
         def token_before_end(node)
-          @token_before_end ||= begin
-            i = tokens(node).index(end_token(node))
-            tokens(node)[i - 1]
-          end
+          i = tokens(node).index(end_token(node))
+          tokens(node)[i - 1]
         end
 
         def break_line_before_end(node, corrector)

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

@@ -60,7 +60,7 @@ module RuboCop
             when :module
               return true
             else
-              return true if pnode.method_name == :instance_eval
+              return true if pnode.method?(:instance_eval)
             end
           end
           false
@@ -95,9 +95,9 @@ module RuboCop
           cop_config['IgnoreClassMethods']
         end
 
-        def whitelist
-          whitelist = cop_config['Whitelist']
-          Array(whitelist).map(&:to_sym) + [:initialize]
+        def allowed_methods
+          allowed_methods = cop_config['AllowedMethods']
+          Array(allowed_methods).map(&:to_sym) + [:initialize]
         end
 
         def dsl_writer?(method_name)
@@ -124,7 +124,7 @@ module RuboCop
         PATTERN
 
         def allowed_method?(node)
-          whitelist.include?(node.method_name) ||
+          allowed_methods.include?(node.method_name) ||
             exact_name_match? && !names_match?(node)
         end