rubocop 0.70.0 → 1.6.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,30 +97,8 @@ module RuboCop
         end
         alias on_csend on_send
 
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        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?
+        def self.autocorrect_incompatible_with
+          [Layout::HeredocArgumentClosingParenthesis]
         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

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

@@ -33,8 +33,8 @@ module RuboCop
       #     end
       #   end
       #
-      class TrailingMethodEndStatement < Cop
-        include Alignment
+      class TrailingMethodEndStatement < Base
+        extend AutoCorrector
 
         MSG = 'Place the end statement of a multi-line method on ' \
               'its own line.'
@@ -42,13 +42,11 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node.to_a.last, location: end_token(node).pos)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            break_line_before_end(node, corrector)
-            remove_semicolon(node, corrector)
+          add_offense(node.loc.end) do |corrector|
+            corrector.insert_before(
+              node.loc.end,
+              "\n#{' ' * node.loc.keyword.column}"
+            )
           end
         end
 
@@ -60,32 +58,9 @@ module RuboCop
             body_and_end_on_same_line?(node)
         end
 
-        def end_token(node)
-          @end_token ||= 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)
-          @token_before_end ||= begin
-            i = tokens(node).index(end_token(node))
-            tokens(node)[i - 1]
-          end
-        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)
+          last_child = node.children.last
+          last_child.loc.last_line == node.loc.end.last_line
         end
       end
     end

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

@@ -20,15 +20,24 @@ 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
+      #
+      class TrailingUnderscoreVariable < Base
         include SurroundingSpace
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
               'Prefer `%<code>s`.'
         UNDERSCORE = '_'
+        DISALLOW = %i[lvasgn splat].freeze
+        private_constant :DISALLOW
 
         def on_masgn(node)
           ranges = unneeded_ranges(node)
@@ -38,17 +47,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, code: good_code))
-          end
-        end
-
-        def autocorrect(node)
-          ranges = unneeded_ranges(node)
-
-          lambda do |corrector|
-            ranges.each { |range| corrector.remove(range) if range }
+            add_offense(range, message: format(MSG, code: good_code)) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 
@@ -65,15 +66,13 @@ module RuboCop
 
         def find_first_possible_offense(variables)
           variables.reduce(nil) do |offense, variable|
-            break offense unless %i[lvasgn splat].include?(variable.type)
+            break offense unless DISALLOW.include?(variable.type)
 
             var, = *variable
             var, = *var
-            if allow_named_underscore_variables
-              break offense unless var == :_
-            else
-              break offense unless var.to_s.start_with?(UNDERSCORE)
-            end
+
+            break offense if (allow_named_underscore_variables && var != :_) ||
+                             !var.to_s.start_with?(UNDERSCORE)
 
             variable
           end
@@ -120,9 +119,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)