rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the module definition.
+      #
+      # @example
+      #   # bad
+      #   module Foo extend self
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     extend self
+      #   end
+      #
+      class TrailingBodyOnModule < Cop
+        include Alignment
+        include TrailingBody
+
+        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|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,24 +4,82 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in argument lists.
+      # The supported styles are:
       #
-      # @example
-      #   # always bad
+      # * `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
       #   method(1, 2,)
       #
-      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
       #   method(
       #     1, 2,
       #     3,
       #   )
       #
-      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   # good
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
       #   method(
       #     1,
       #     2,
       #   )
       #
-      #   # good if EnforcedStyleForMultiline is no_comma
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # 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,
+      #     2,
+      #   )
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
       #   method(
       #     1,
       #     2
@@ -32,31 +90,18 @@ module RuboCop
         def on_send(node)
           return unless node.arguments? && node.parenthesized?
 
-          check(node, node.arguments, 'parameter of %s method call',
+          check(node, node.arguments, 'parameter of %<article>s method call',
                 node.last_argument.source_range.end_pos,
                 node.source_range.end_pos)
         end
+        alias on_csend on_send
 
-        private
-
-        def avoid_autocorrect?(args)
-          args.last.hash_type? && args.last.braces? &&
-            braces_will_be_removed?(args)
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
         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?
+        def self.autocorrect_incompatible_with
+          [Layout::HeredocArgumentClosingParenthesis]
         end
       end
     end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+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,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   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,
+      #   ]
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2
+      #   ]
+      class TrailingCommaInArrayLiteral < Cop
+        include TrailingComma
+
+        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
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+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,
+      #   }
+      #
+      #   # 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, }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2
+      #   }
+      class TrailingCommaInHashLiteral < Cop
+        include TrailingComma
+
+        def on_hash(node)
+          check_literal(node, 'item of %<article>s hash')
+        end
+
+        def autocorrect(range)
+          PunctuationCorrector.swap_comma(range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the method definition.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #   do_stuff; end
+      #
+      #   def do_this(x)
+      #     baz.map { |b| b.this(x) } end
+      #
+      #   def foo
+      #     block do
+      #       bar
+      #     end end
+      #
+      #   # good
+      #   def some_method
+      #     do_stuff
+      #   end
+      #
+      #   def do_this(x)
+      #     baz.map { |b| b.this(x) }
+      #   end
+      #
+      #   def foo
+      #     block do
+      #       bar
+      #     end
+      #   end
+      #
+      class TrailingMethodEndStatement < Cop
+        include Alignment
+
+        MSG = 'Place the end statement of a multi-line method on ' \
+              'its own line.'
+
+        def on_def(node)
+          return unless trailing_end?(node)
+
+          add_offense(node, location: end_token(node).pos)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            break_line_before_end(node, corrector)
+            remove_semicolon(node, corrector)
+          end
+        end
+
+        private
+
+        def trailing_end?(node)
+          node.body &&
+            node.multiline? &&
+            body_and_end_on_same_line?(node)
+        end
+
+        def end_token(node)
+          tokens(node).reverse.find(&:end?)
+        end
+
+        def body_and_end_on_same_line?(node)
+          end_token(node).line == token_before_end(node).line
+        end
+
+        def token_before_end(node)
+          i = tokens(node).index(end_token(node))
+          tokens(node)[i - 1]
+        end
+
+        def break_line_before_end(node, corrector)
+          corrector.insert_before(
+            end_token(node).pos,
+            "\n" + ' ' * configured_indentation_width
+          )
+        end
+
+        def remove_semicolon(node, corrector)
+          return unless token_before_end(node).semicolon?
+
+          corrector.remove(token_before_end(node).pos)
+        end
+      end
+    end
+  end
+end

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

@@ -15,17 +15,26 @@ module RuboCop
       #   # good
       #   a, b, = foo()
       #   a, = foo()
-      #   *a, b, _ = foo()  => We need to know to not include 2 variables in a
-      #   a, *b, _ = foo()  => The correction `a, *b, = foo()` is a syntax error
+      #   *a, b, _ = foo()
+      #   # => We need to know to not include 2 variables in a
+      #   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
 
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
-              'Prefer `%s`.'.freeze
-        UNDERSCORE = '_'.freeze
+              'Prefer `%<code>s`.'
+        UNDERSCORE = '_'
 
         def on_masgn(node)
           ranges = unneeded_ranges(node)
@@ -35,7 +44,9 @@ module RuboCop
             offset = range.begin_pos - node.source_range.begin_pos
             good_code[offset, range.size] = ''
 
-            add_offense(node, location: range, message: format(MSG, good_code))
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, code: good_code))
           end
         end
 
@@ -61,6 +72,7 @@ module RuboCop
         def find_first_possible_offense(variables)
           variables.reduce(nil) do |offense, variable|
             break offense unless %i[lvasgn splat].include?(variable.type)
+
             var, = *variable
             var, = *var
             if allow_named_underscore_variables
@@ -114,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)