rubocop 0.78.0 → 0.82.0

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

@@ -41,7 +41,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             symbol_content = node.str_content.to_sym.inspect
-            corrector.replace(node.source_range, symbol_content)
+            corrector.replace(node, symbol_content)
           end
         end
       end

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
@@ -81,7 +81,7 @@ module RuboCop
           end
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "[#{syms.join(', ')}]")
+            corrector.replace(node, "[#{syms.join(', ')}]")
           end
         end
 

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

@@ -16,14 +16,14 @@ module RuboCop
         MSG = 'Do not use strings for word-like symbol literals.'
 
         def on_sym(node)
-          return unless node.source =~ /\A:["'][A-Za-z_]\w*["']\z/
+          return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
 
           add_offense(node)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, node.source.delete(%q('")))
+            corrector.replace(node, node.source.delete(%q('")))
           end
         end
       end

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
 
@@ -207,8 +207,7 @@ module RuboCop
 
         def correct_unparenthesized(condition)
           lambda do |corrector|
-            corrector.insert_before(condition.source_range, '(')
-            corrector.insert_after(condition.source_range, ')')
+            corrector.wrap(condition, '(', ')')
           end
         end
 

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

@@ -4,6 +4,14 @@ 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`: Requires that there is no comma after the last
+      # argument.
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -20,6 +28,11 @@ module RuboCop
       #
       #   # good
       #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
       #     1,
       #     2,
       #   )
@@ -31,6 +44,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 +103,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,88 @@
+# 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)
+          # lambda literal (`->`) never has block arguments.
+          return if node.send_node.lambda_literal?
+
+          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/trivial_accessors.rb

@@ -161,7 +161,7 @@ module RuboCop
           return unless names_match?(node) && !node.predicate_method? && kind
 
           lambda do |corrector|
-            corrector.replace(node.source_range,
+            corrector.replace(node,
                               accessor(kind, node.method_name))
           end
         end

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

@@ -18,10 +18,6 @@ module RuboCop
       #   'foo'.unpack1('h*')
       #
       class UnpackFirst < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
-
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
           '`%<receiver>s.unpack(%<format>s)%<method>s`.'
 

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

@@ -29,7 +29,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
+            corrector.replace(node, "{#{node.source}}")
           end
         end
 

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

@@ -43,7 +43,7 @@ module RuboCop
                     "#{node.condition.source}"
 
           lambda do |corrector|
-            corrector.replace(node.source_range, oneline)
+            corrector.replace(node, oneline)
           end
         end
 

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

@@ -93,7 +93,7 @@ module RuboCop
           end
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "[#{words.join(', ')}]")
+            corrector.replace(node, "[#{words.join(', ')}]")
           end
         end
       end

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