rubocop 0.75.1 → 0.93.1

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

@@ -15,20 +15,17 @@ module RuboCop
       #     def foo; end
       #   end
       #
-      class TrailingBodyOnClass < Cop
+      class TrailingBodyOnClass < Base
         include Alignment
         include TrailingBody
+        extend AutoCorrector
 
         MSG = 'Place the first line of class body on its own line.'
 
         def on_class(node)
           return unless trailing_body?(node)
 
-          add_offense(node, location: first_part_of(node.to_a.last))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(first_part_of(node.to_a.last)) do |corrector|
             LineBreakCorrector.correct_trailing_body(
               configured_width: configured_indentation_width,
               corrector: corrector,

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

@@ -24,9 +24,10 @@ module RuboCop
       #     b[c: x]
       #   end
       #
-      class TrailingBodyOnMethodDefinition < Cop
+      class TrailingBodyOnMethodDefinition < Base
         include Alignment
         include TrailingBody
+        extend AutoCorrector
 
         MSG = "Place the first line of a multi-line method definition's " \
               'body on its own line.'
@@ -34,12 +35,7 @@ module RuboCop
         def on_def(node)
           return unless trailing_body?(node)
 
-          add_offense(node, location: first_part_of(node.body))
-        end
-        alias on_defs on_def
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(first_part_of(node.body)) do |corrector|
             LineBreakCorrector.correct_trailing_body(
               configured_width: configured_indentation_width,
               corrector: corrector,
@@ -48,6 +44,7 @@ module RuboCop
             )
           end
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -15,20 +15,17 @@ module RuboCop
       #     extend self
       #   end
       #
-      class TrailingBodyOnModule < Cop
+      class TrailingBodyOnModule < Base
         include Alignment
         include TrailingBody
+        extend AutoCorrector
 
         MSG = 'Place the first line of module body on its own line.'
 
         def on_module(node)
           return unless trailing_body?(node)
 
-          add_offense(node, location: first_part_of(node.to_a.last))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(first_part_of(node.to_a.last)) do |corrector|
             LineBreakCorrector.correct_trailing_body(
               configured_width: configured_indentation_width,
               corrector: corrector,

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,
@@ -49,8 +84,9 @@ module RuboCop
       #     1,
       #     2
       #   )
-      class TrailingCommaInArguments < Cop
+      class TrailingCommaInArguments < Base
         include TrailingComma
+        extend AutoCorrector
 
         def on_send(node)
           return unless node.arguments? && node.parenthesized?
@@ -61,35 +97,9 @@ module RuboCop
         end
         alias on_csend on_send
 
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        end
-
         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,
@@ -40,18 +81,15 @@ module RuboCop
       #     1,
       #     2
       #   ]
-      class TrailingCommaInArrayLiteral < Cop
+      class TrailingCommaInArrayLiteral < Base
         include TrailingComma
+        extend AutoCorrector
 
         def on_array(node)
           return unless node.square_brackets?
 
           check_literal(node, 'item of %<article>s array')
         end
-
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        end
       end
     end
   end

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

@@ -0,0 +1,90 @@
+# 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 < Base
+        extend AutoCorrector
+
+        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)
+
+          last_comma_pos = last_comma(node).pos
+
+          add_offense(last_comma_pos) do |corrector|
+            corrector.replace(last_comma_pos, '')
+          end
+        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)
+          tokens = processed_source.tokens_within(node)
+          pipes = tokens.select { |token| token.type == :tPIPE }
+          begin_pos, end_pos = pipes.map do |pipe|
+            tokens.index(pipe)
+          end
+
+          tokens[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, }
       #
@@ -40,16 +84,13 @@ module RuboCop
       #     foo: 1,
       #     bar: 2
       #   }
-      class TrailingCommaInHashLiteral < Cop
+      class TrailingCommaInHashLiteral < Base
         include TrailingComma
+        extend AutoCorrector
 
         def on_hash(node)
           check_literal(node, 'item of %<article>s hash')
         end
-
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        end
       end
     end
   end