rubocop 0.77.0 → 0.81.0

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

@@ -46,7 +46,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             if node.ternary?
-              corrector.replace(range_of_offense(node), '||')
+              correct_ternary(corrector, node)
             elsif node.modifier_form? || !node.else_branch
               corrector.replace(node.source_range, node.if_branch.source)
             else
@@ -90,9 +90,13 @@ module RuboCop
         end
 
         def else_source(else_branch)
-          wrap_else =
-            else_branch.basic_conditional? && else_branch.modifier_form?
-          wrap_else ? "(#{else_branch.source})" : else_branch.source
+          if else_branch.basic_conditional? &&
+             else_branch.modifier_form? ||
+             else_branch.range_type?
+            "(#{else_branch.source})"
+          else
+            else_branch.source
+          end
         end
 
         def make_ternary_form(node)
@@ -106,6 +110,15 @@ module RuboCop
             ternary_form
           end
         end
+
+        def correct_ternary(corrector, node)
+          corrector.replace(range_of_offense(node), '||')
+
+          return unless node.else_branch.range_type?
+
+          corrector.insert_before(node.else_branch.loc.expression, '(')
+          corrector.insert_after(node.else_branch.loc.expression, ')')
+        end
       end
     end
   end

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

@@ -63,9 +63,9 @@ module RuboCop
             (send $(send _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send (block $(send _ ${:sort_by :sort}) ...) ${:last :first})
+            (send ({block numblock} $(send _ ${:sort_by :sort}) ...) ${:last :first})
             (send
-              (block $(send _ ${:sort_by :sort}) ...)
+              ({block numblock} $(send _ ${:sort_by :sort}) ...)
               ${:[] :at :slice} {(int 0) (int -1)}
             )
           }

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

@@ -11,8 +11,8 @@ module RuboCop
       #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
-      # cop. For example, a `MinSize of `3` will not enforce a style on an array
-      # of 2 or fewer elements.
+      # cop. For example, a `MinSize` of `3` will not enforce a style on an
+      # array of 2 or fewer elements.
       #
       # @example EnforcedStyle: percent (default)
       #   # good

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

@@ -162,7 +162,7 @@ module RuboCop
         # `RedundantParentheses` cop is enabled, it will cause an infinite loop
         # as they compete to add and remove the parentheses respectively.
         def infinite_loop?
-          require_parentheses? &&
+          (require_parentheses? || require_parentheses_when_complex?) &&
             redundant_parentheses_enabled?
         end
 

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

@@ -4,6 +4,13 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in argument lists.
+      # The supported styles are:
+      #
+      # - `consistent_comma`: Requires a comma after the last argument,
+      # for all parenthesized method calls with arguments.
+      # - `comma`: Requires a comma after the last argument, but only for
+      # parenthesized method calls where each argument is on its own line.
+      # - `no_comma`: Does not requires a comma after the last argument.
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -20,6 +27,11 @@ module RuboCop
       #
       #   # good
       #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
       #     1,
       #     2,
       #   )
@@ -31,6 +43,28 @@ module RuboCop
       #   # good
       #   method(1, 2)
       #
+      #   # bad
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3
+      #   )
+      #
+      #   # bad
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2, 3
+      #   )
+      #
       #   # good
       #   method(
       #     1,
@@ -68,28 +102,6 @@ module RuboCop
         def self.autocorrect_incompatible_with
           [Layout::HeredocArgumentClosingParenthesis]
         end
-
-        private
-
-        def avoid_autocorrect?(args)
-          args.last.hash_type? && args.last.braces? &&
-            braces_will_be_removed?(args)
-        end
-
-        # Returns true if running with --auto-correct would remove the braces
-        # of the last argument.
-        def braces_will_be_removed?(args)
-          brace_config = config.for_cop('Style/BracesAroundHashParameters')
-          return false unless brace_config.fetch('Enabled')
-          return false if brace_config['AutoCorrect'] == false
-
-          brace_style = brace_config['EnforcedStyle']
-          return true if brace_style == 'no_braces'
-
-          return false unless brace_style == 'context_dependent'
-
-          args.one? || !args[-2].hash_type?
-        end
       end
     end
   end

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

@@ -4,12 +4,23 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in array literals.
+      # The configuration options are:
+      #
+      # - `consistent_comma`: Requires a comma after the
+      # last item of all non-empty, multiline array literals.
+      # - `comma`: Requires a comma after last item in an array,
+      # but only when each item is on its own line.
+      # - `no_comma`: Does not requires a comma after the
+      # last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
       #   a = [1, 2,]
       #
       #   # good
+      #   a = [1, 2]
+      #
+      #   # good
       #   a = [
       #     1, 2,
       #     3,
@@ -17,6 +28,11 @@ module RuboCop
       #
       #   # good
       #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
       #     1,
       #     2,
       #   ]
@@ -26,6 +42,31 @@ module RuboCop
       #   a = [1, 2,]
       #
       #   # good
+      #   a = [1, 2]
+      #
+      #   # bad
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2,
+      #     3
+      #   ]
+      #
+      #   # bad
+      #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2, 3
+      #   ]
+      #
+      #   # good
       #   a = [
       #     1,
       #     2,

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether trailing commas in block arguments are
+      # required. Blocks with only one argument and a trailing comma require
+      # that comma to be present. Blocks with more than one argument never
+      # require a trailing comma.
+      #
+      # @example
+      #   # bad
+      #   add { |foo, bar,| foo + bar }
+      #
+      #    # good
+      #   add { |foo, bar| foo + bar }
+      #
+      #   # good
+      #   add { |foo,| foo }
+      #
+      #   # good
+      #   add { foo }
+      #
+      #   # bad
+      #  add do |foo, bar,|
+      #    foo + bar
+      #   end
+      #
+      #  # good
+      #  add do |foo, bar|
+      #    foo + bar
+      #  end
+      #
+      #  # good
+      #   add do |foo,|
+      #    foo
+      #  end
+      #
+      #  # good
+      #  add do
+      #     foo + bar
+      #  end
+      class TrailingCommaInBlockArgs < Cop
+        MSG = 'Useless trailing comma present in block arguments.'
+
+        def on_block(node)
+          return unless useless_trailing_comma?(node)
+
+          add_offense(node, location: last_comma(node).pos)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(last_comma(node).pos, '') }
+        end
+
+        private
+
+        def useless_trailing_comma?(node)
+          arg_count(node) > 1 && trailing_comma?(node)
+        end
+
+        def arg_count(node)
+          node.arguments.each_descendant(:arg, :optarg, :kwoptarg).to_a.size
+        end
+
+        def trailing_comma?(node)
+          argument_tokens(node).last.comma?
+        end
+
+        def last_comma(node)
+          argument_tokens(node).last
+        end
+
+        def argument_tokens(node)
+          pipes = tokens(node).select { |token| token.type == :tPIPE }
+          begin_pos, end_pos = pipes.map do |pipe|
+            tokens(node).index(pipe)
+          end
+
+          tokens(node)[begin_pos + 1..end_pos - 1]
+        end
+      end
+    end
+  end
+end

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

@@ -4,12 +4,24 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in hash literals.
+      # The configuration options are:
+      #
+      # - `consistent_comma`: Requires a comma after the
+      # last item of all non-empty, multiline hash literals.
+      # - `comma`: Requires a comma after the last item in a hash,
+      # but only when each item is on its own line.
+      # - `no_comma`: Does not requires a comma after the
+      # last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma
+      #
       #   # bad
       #   a = { foo: 1, bar: 2, }
       #
       #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # good
       #   a = {
       #     foo: 1, bar: 2,
       #     qux: 3,
@@ -17,21 +29,53 @@ module RuboCop
       #
       #   # good
       #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
       #     foo: 1,
       #     bar: 2,
       #   }
       #
       # @example EnforcedStyleForMultiline: comma
+      #
       #   # bad
       #   a = { foo: 1, bar: 2, }
       #
       #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # bad
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3
+      #   }
+      #
+      #   # bad
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3
+      #   }
+      #
+      #   # good
       #   a = {
       #     foo: 1,
       #     bar: 2,
       #   }
       #
       # @example EnforcedStyleForMultiline: no_comma (default)
+      #
       #   # bad
       #   a = { foo: 1, bar: 2, }
       #

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

@@ -20,8 +20,14 @@ module RuboCop
       #   a, *b, _ = foo()
       #   # => The correction `a, *b, = foo()` is a syntax error
       #
-      #   # good if AllowNamedUnderscoreVariables is true
+      # @example AllowNamedUnderscoreVariables: true (default)
+      #   # good
       #   a, b, _something = foo()
+      #
+      # @example AllowNamedUnderscoreVariables: false
+      #   # bad
+      #   a, b, _something = foo()
+      #
       class TrailingUnderscoreVariable < Cop
         include SurroundingSpace
         include RangeHelp

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Checks for while and until statements that would fit on one line
       # if written as a modifier while/until. The maximum line length is
-      # configured in the `Metrics/LineLength` cop.
+      # configured in the `Layout/LineLength` cop.
       #
       # @example
       #   # bad

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

@@ -67,9 +67,16 @@ module RuboCop
 
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
 
+        PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+
+        def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
+          (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
+        PATTERN
+
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node)
+          return if equality_only? && non_equality_operator?(node) ||
+                    file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node)
         end
@@ -135,6 +142,14 @@ module RuboCop
         def noncommutative_operator?(node)
           NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
         end
+
+        def source_file_path_constant?(node)
+          node.source == '__FILE__'
+        end
+
+        def program_name?(name)
+          PROGRAM_NAMES.include?(name)
+        end
       end
     end
   end