rubocop 0.80.1 → 0.85.0

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

@@ -88,7 +88,7 @@ module RuboCop
         def apply_autocorrect(node, rhs, operator, new_rhs)
           lambda do |corrector|
             corrector.insert_before(node.loc.operator, operator)
-            corrector.replace(rhs.source_range, new_rhs.source)
+            corrector.replace(rhs, new_rhs.source)
           end
         end
       end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that arrays are sliced with endless ranges instead of
+      # `ary[start..-1]` on Ruby 2.6+.
+      #
+      # @example
+      #   # bad
+      #   items[1..-1]
+      #
+      #   # good
+      #   items[1..]
+      class SlicingWithRange < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer ary[n..] over ary[n..-1].'
+
+        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
+
+        def on_send(node)
+          return unless node.method?(:[]) && node.arguments.count == 1
+          return unless range_till_minus_one?(node.arguments.first)
+
+          add_offense(node.arguments.first)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -145,7 +145,7 @@ module RuboCop
               node = node.parent
             end
 
-            corrector.replace(node.source_range, replacement(node, global_var))
+            corrector.replace(node, replacement(node, global_var))
           end
         end
 
@@ -181,13 +181,9 @@ module RuboCop
           parent_type = node.parent&.type
           preferred_name = preferred_names(global_var).first
 
-          unless %i[dstr xstr regexp].include?(parent_type)
-            return preferred_name.to_s
-          end
+          return preferred_name.to_s unless %i[dstr xstr regexp].include?(parent_type)
 
-          if style == :use_english_names
-            return english_name_replacement(preferred_name, node)
-          end
+          return english_name_replacement(preferred_name, node) if style == :use_english_names
 
           "##{preferred_name}"
         end

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

@@ -57,10 +57,7 @@ module RuboCop
 
         def missing_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node.loc.expression
-
-            corrector.insert_before(args_loc, '(')
-            corrector.insert_after(args_loc, ')')
+            corrector.wrap(node, '(', ')')
           end
         end
 

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

@@ -81,7 +81,7 @@ module RuboCop
           end
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "[#{syms.join(', ')}]")
+            corrector.replace(node, "[#{syms.join(', ')}]")
           end
         end
 
@@ -106,7 +106,7 @@ module RuboCop
           # method name
           string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
             # instance / class variable
-            string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
+            string =~ /\A@@?[a-zA-Z_]\w*\z/ ||
             # global variable
             string =~ /\A\$[1-9]\d*\z/ ||
             string =~ /\A\$[a-zA-Z_]\w*\z/ ||

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

@@ -199,16 +199,13 @@ module RuboCop
             # Ruby allows no space between the question mark and parentheses.
             # If we remove the parentheses, we need to add a space or we'll
             # generate invalid code.
-            unless whitespace_after?(condition)
-              corrector.insert_after(condition.loc.end, ' ')
-            end
+            corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
           end
         end
 
         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,

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/trailing_underscore_variable.rb

@@ -126,9 +126,7 @@ module RuboCop
             return unused_range(node.type, mlhs_node, right)
           end
 
-          if Util.parentheses?(mlhs_node)
-            return range_for_parentheses(first_offense, mlhs_node)
-          end
+          return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
 
           range_between(first_offense.source_range.begin_pos,
                         node.loc.operator.begin_pos)