rubocop 0.49.1 → 0.52.0

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

@@ -0,0 +1,101 @@
+# 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 f(x); b = foo
+      #     b[c: x]
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_stuff
+      #   end
+      #
+      #   def f(x)
+      #     b = foo
+      #     b[c: x]
+      #   end
+      #
+      class TrailingBodyOnMethodDefinition < Cop
+        include AutocorrectAlignment
+
+        MSG = "Place the first line of a multi-line method definition's " \
+              'body on its own line.'.freeze
+
+        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|
+            break_line_before_body(node, corrector)
+            move_comment(node, corrector)
+            remove_semicolon(corrector)
+          end
+        end
+
+        private
+
+        def trailing_body?(node)
+          node.body && node.multiline? && on_def_line?(node)
+        end
+
+        def on_def_line?(node)
+          node.source_range.first_line == node.body.source_range.first_line
+        end
+
+        def break_line_before_body(node, corrector)
+          corrector.insert_before(
+            first_part_of(node.body),
+            "\n" + ' ' * (node.loc.keyword.column +
+                          configured_indentation_width)
+          )
+        end
+
+        def first_part_of(body)
+          if body.begin_type?
+            body.children.first.source_range
+          else
+            body.source_range
+          end
+        end
+
+        def move_comment(node, corrector)
+          eol_comment = end_of_line_comment(node.source_range.line)
+          return unless eol_comment
+
+          text = eol_comment.loc.expression.source
+          corrector.insert_before(node.source_range,
+                                  text + "\n" + (' ' * node.loc.keyword.column))
+          corrector.remove(eol_comment.loc.expression)
+        end
+
+        def end_of_line_comment(line)
+          processed_source.comments.find { |c| c.loc.line == line }
+        end
+
+        def remove_semicolon(corrector)
+          return unless semicolon
+          corrector.remove(semicolon.pos)
+        end
+
+        def semicolon
+          @semicolon ||= processed_source.tokens.find do |token|
+            token.line == 1 && token.semicolon?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,23 +5,37 @@ module RuboCop
     module Style
       # This cop checks for trailing comma in argument lists.
       #
-      # @example
-      #   # always bad
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
       #   method(1, 2,)
       #
-      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   # good
       #   method(
       #     1, 2,
       #     3,
       #   )
       #
-      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   # good
       #   method(
       #     1,
       #     2,
       #   )
       #
-      #   # good if EnforcedStyleForMultiline is no_comma
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
       #   method(
       #     1,
       #     2
@@ -32,7 +46,7 @@ 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

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

@@ -5,23 +5,37 @@ module RuboCop
     module Style
       # This cop checks for trailing comma in array and hash literals.
       #
-      # @example
-      #   # always bad
+      # @example EnforcedStyleForMultiline: consistent_comma
+      #   # bad
       #   a = [1, 2,]
       #
-      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   # good
       #   a = [
       #     1, 2,
       #     3,
       #   ]
       #
-      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   # good
       #   a = [
       #     1,
       #     2,
       #   ]
       #
-      #   # good if EnforcedStyleForMultiline is no_comma
+      # @example EnforcedStyleForMultiline: comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      # @example EnforcedStyleForMultiline: no_comma (default)
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
       #   a = [
       #     1,
       #     2
@@ -31,11 +45,12 @@ module RuboCop
         include TrailingComma
 
         def on_array(node)
-          check_literal(node, 'item of %s array') if node.square_brackets?
+          return unless node.square_brackets?
+          check_literal(node, 'item of %<article>s array')
         end
 
         def on_hash(node)
-          check_literal(node, 'item of %s hash')
+          check_literal(node, 'item of %<article>s hash')
         end
 
         private

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

@@ -0,0 +1,95 @@
+# 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 AutocorrectAlignment
+
+        MSG = 'Place the end statement of a multi-line method on ' \
+              'its own line.'.freeze
+
+        def on_def(node)
+          return unless trailing_end?(node)
+
+          add_offense(node.to_a.last, location: end_token.pos)
+        end
+
+        def autocorrect(_node)
+          lambda do |corrector|
+            break_line_before_end(corrector)
+            remove_semicolon(corrector)
+          end
+        end
+
+        private
+
+        def trailing_end?(node)
+          node.body &&
+            node.multiline? &&
+            end_token &&
+            body_and_end_on_same_line?
+        end
+
+        def end_token
+          @end_token ||= processed_source.tokens.reverse.find do |token|
+            token.type == :kEND
+          end
+        end
+
+        def body_and_end_on_same_line?
+          end_token.line == token_before_end.line
+        end
+
+        def token_before_end
+          @token_before_end ||= begin
+            i = processed_source.tokens.index(end_token)
+            processed_source.tokens[i - 1]
+          end
+        end
+
+        def break_line_before_end(corrector)
+          corrector.insert_before(
+            end_token.pos,
+            "\n" + ' ' * configured_indentation_width
+          )
+        end
+
+        def remove_semicolon(corrector)
+          return unless token_before_end.semicolon?
+          corrector.remove(token_before_end.pos)
+        end
+      end
+    end
+  end
+end

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

@@ -15,8 +15,10 @@ 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
       #   a, b, _something = foo()
@@ -24,26 +26,28 @@ module RuboCop
         include SurroundingSpace
 
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
-              'Prefer `%s`.'.freeze
+              'Prefer `%<code>s`.'.freeze
         UNDERSCORE = '_'.freeze
 
         def on_masgn(node)
-          range = unneeded_range(node)
+          ranges = unneeded_ranges(node)
 
-          return unless range
+          ranges.each do |range|
+            good_code = node.source
+            offset = range.begin_pos - node.source_range.begin_pos
+            good_code[offset, range.size] = ''
 
-          good_code = node.source
-          offset = range.begin_pos - node.source_range.begin_pos
-          good_code[offset, range.size] = ''
-
-          add_offense(node, range, format(MSG, good_code))
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, code: good_code))
+          end
         end
 
         def autocorrect(node)
-          range = unneeded_range(node)
+          ranges = unneeded_ranges(node)
 
           lambda do |corrector|
-            corrector.remove(range) if range
+            ranges.each { |range| corrector.remove(range) if range }
           end
         end
 
@@ -60,6 +64,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
@@ -89,23 +94,64 @@ module RuboCop
             cop_config['AllowNamedUnderscoreVariables']
         end
 
-        def unneeded_range(node)
-          left, right = *node
-          variables = *left
+        def unneeded_ranges(node)
+          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
+          variables = *mlhs_node
+
+          main_offense = main_node_offense(node)
+          if main_offense.nil?
+            children_offenses(variables)
+          else
+            children_offenses(variables) << main_offense
+          end
+        end
+
+        def main_node_offense(node)
+          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
+
+          variables = *mlhs_node
           first_offense = find_first_offense(variables)
 
           return unless first_offense
 
-          end_position =
-            if first_offense.source_range == variables.first.source_range
-              right.source_range.begin_pos
-            else
-              node.loc.operator.begin_pos
-            end
+          if unused_variables_only?(first_offense, variables)
+            return unused_range(node.type, mlhs_node, right)
+          end
+
+          if Util.parentheses?(mlhs_node)
+            return range_for_parentheses(first_offense, mlhs_node)
+          end
+
+          range_between(first_offense.source_range.begin_pos,
+                        node.loc.operator.begin_pos)
+        end
+
+        def children_offenses(variables)
+          variables.select(&:mlhs_type?).flat_map { |v| unneeded_ranges(v) }
+        end
+
+        def unused_variables_only?(offense, variables)
+          offense.source_range == variables.first.source_range
+        end
+
+        def unused_range(node_type, mlhs_node, right)
+          start_range = mlhs_node.source_range.begin_pos
+
+          end_range = case node_type
+                      when :masgn
+                        right.source_range.begin_pos
+                      when :mlhs
+                        mlhs_node.source_range.end_pos
+                      end
+
+          range_between(start_range, end_range)
+        end
 
-          range = range_between(first_offense.source_range.begin_pos,
-                                end_position)
-          range_with_surrounding_space(range, :right)
+        def range_for_parentheses(offense, left)
+          range_between(
+            offense.source_range.begin_pos - 1,
+            left.loc.expression.end_pos - 1
+          )
         end
       end
     end

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

@@ -5,20 +5,45 @@ module RuboCop
     module Style
       # This cop looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     @foo
+      #   end
+      #
+      #   def bar=(val)
+      #     @bar = val
+      #   end
+      #
+      #   def self.baz
+      #     @baz
+      #   end
+      #
+      #   # good
+      #   attr_reader :foo
+      #   attr_writer :bar
+      #
+      #   class << self
+      #     attr_reader :baz
+      #   end
       class TrivialAccessors < Cop
-        MSG = 'Use `attr_%s` to define trivial %s methods.'.freeze
+        MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'.freeze
 
         def on_def(node)
           return if in_module_or_instance_eval?(node)
-          method_name, args, body = *node
-          on_method_def(node, method_name, args, body)
+          return if ignore_class_methods? && node.defs_type?
+
+          on_method_def(node)
         end
+        alias on_defs on_def
 
-        def on_defs(node)
-          return if in_module_or_instance_eval?(node)
-          return if ignore_class_methods?
-          _scope, method_name, args, body = *node
-          on_method_def(node, method_name, args, body)
+        def autocorrect(node)
+          if node.def_type?
+            autocorrect_instance(node)
+          elsif node.defs_type? && node.children.first.self_type?
+            autocorrect_class(node)
+          end
         end
 
         private
@@ -37,15 +62,17 @@ module RuboCop
           false
         end
 
-        def on_method_def(node, method_name, args, body)
-          kind = if trivial_reader?(method_name, args, body)
+        def on_method_def(node)
+          kind = if trivial_reader?(node)
                    'reader'
-                 elsif trivial_writer?(method_name, args, body)
+                 elsif trivial_writer?(node)
                    'writer'
                  end
           return unless kind
 
-          add_offense(node, :keyword, format(MSG, kind, kind))
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, kind: kind))
         end
 
         def exact_name_match?
@@ -69,61 +96,53 @@ module RuboCop
           Array(whitelist).map(&:to_sym) + [:initialize]
         end
 
-        def predicate?(method_name)
-          method_name[-1] == '?'
-        end
-
         def dsl_writer?(method_name)
           !method_name.to_s.end_with?('=')
         end
 
-        def trivial_reader?(method_name, args, body)
-          looks_like_trivial_reader?(args, body) &&
-            !allowed_method?(method_name, body) &&
-            !allowed_reader?(method_name)
+        def trivial_reader?(node)
+          looks_like_trivial_reader?(node) &&
+            !allowed_method?(node) && !allowed_reader?(node)
         end
 
-        def looks_like_trivial_reader?(args, body)
-          args.children.empty? && body && body.ivar_type?
+        def looks_like_trivial_reader?(node)
+          !node.arguments? && node.body && node.body.ivar_type?
         end
 
-        def trivial_writer?(method_name, args, body)
-          looks_like_trivial_writer?(args, body) &&
-            !allowed_method?(method_name, body) &&
-            !allowed_writer?(method_name)
+        def trivial_writer?(node)
+          looks_like_trivial_writer?(node) &&
+            !allowed_method?(node) && !allowed_writer?(node.method_name)
         end
 
-        def looks_like_trivial_writer?(args, body)
-          args.children.one? &&
-            !%i[restarg blockarg].include?(args.children[0].type) &&
-            body && body.ivasgn_type? &&
-            body.children[1] && body.children[1].lvar_type?
-        end
+        def_node_matcher :looks_like_trivial_writer?, <<-PATTERN
+          {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
+           (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
+        PATTERN
 
-        def allowed_method?(method_name, body)
-          whitelist.include?(method_name) ||
-            exact_name_match? && !names_match?(method_name, body)
+        def allowed_method?(node)
+          whitelist.include?(node.method_name) ||
+            exact_name_match? && !names_match?(node)
         end
 
         def allowed_writer?(method_name)
           allow_dsl_writers? && dsl_writer?(method_name)
         end
 
-        def allowed_reader?(method_name)
-          allow_predicates? && predicate?(method_name)
+        def allowed_reader?(node)
+          allow_predicates? && node.predicate_method?
         end
 
-        def names_match?(method_name, body)
-          ivar_name, = *body
+        def names_match?(node)
+          ivar_name, = *node.body
 
-          method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
+          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
         end
 
-        def trivial_accessor_kind(method_name, args, body)
-          if trivial_writer?(method_name, args, body) &&
-             !dsl_writer?(method_name)
+        def trivial_accessor_kind(node)
+          if trivial_writer?(node) &&
+             !dsl_writer?(node.method_name)
             'writer'
-          elsif trivial_reader?(method_name, args, body)
+          elsif trivial_reader?(node)
             'reader'
           end
         end
@@ -132,40 +151,28 @@ module RuboCop
           "attr_#{kind} :#{method_name.to_s.chomp('=')}"
         end
 
-        def autocorrect(node)
-          if node.def_type?
-            autocorrect_instance(node)
-          elsif node.defs_type? && node.children.first.self_type?
-            autocorrect_class(node)
-          end
-        end
-
         def autocorrect_instance(node)
-          method_name, args, body = *node
-          unless names_match?(method_name, body) &&
-                 !predicate?(method_name) &&
-                 (kind = trivial_accessor_kind(method_name, args, body))
-            return
-          end
+          kind = trivial_accessor_kind(node)
+
+          return unless names_match?(node) && !node.predicate_method? && kind
 
           lambda do |corrector|
-            corrector.replace(node.source_range, accessor(kind, method_name))
+            corrector.replace(node.source_range,
+                              accessor(kind, node.method_name))
           end
         end
 
         def autocorrect_class(node)
-          _, method_name, args, body = *node
-          unless names_match?(method_name, body) &&
-                 (kind = trivial_accessor_kind(method_name, args, body))
-            return
-          end
+          kind = trivial_accessor_kind(node)
+
+          return unless names_match?(node) && kind
 
           lambda do |corrector|
             indent = ' ' * node.loc.column
             corrector.replace(
               node.source_range,
               ['class << self',
-               "#{indent}  #{accessor(kind, method_name)}",
+               "#{indent}  #{accessor(kind, node.method_name)}",
                "#{indent}end"].join("\n")
             )
           end