rubocop 0.42.0 → 0.52.1

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 Alignment
+
+        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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -13,59 +12,81 @@ module RuboCop
       #   a, _, _ = foo()
       #   a, _, _, = foo()
       #
-      #   #good
+      #   # 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()
       class TrailingUnderscoreVariable < Cop
         include SurroundingSpace
 
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
-              'Prefer `%s`.'.freeze
+              'Prefer `%<code>s`.'.freeze
         UNDERSCORE = '_'.freeze
 
         def on_masgn(node)
-          return unless (range = unneeded_range(node))
+          ranges = unneeded_ranges(node)
 
-          good_code = node.source
-          offset = range.begin_pos - node.source_range.begin_pos
-          good_code[offset, range.size] = ''
+          ranges.each do |range|
+            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)
+          ranges = unneeded_ranges(node)
+
           lambda do |corrector|
-            range = unneeded_range(node)
-            corrector.remove(range) if range
+            ranges.each { |range| corrector.remove(range) if range }
           end
         end
 
         private
 
         def find_first_offense(variables)
-          first_offense = nil
+          first_offense = find_first_possible_offense(variables.reverse)
+
+          return unless first_offense
+          return if splat_variable_before?(first_offense, variables)
 
-          variables.reverse_each do |variable|
+          first_offense
+        end
+
+        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
-              break unless var == :_
+              break offense unless var == :_
             else
-              break unless var.to_s.start_with?(UNDERSCORE)
+              break offense unless var.to_s.start_with?(UNDERSCORE)
             end
-            first_offense = variable
+
+            variable
           end
+        end
 
-          return nil if first_offense.nil?
+        def splat_variable_before?(first_offense, variables)
+          # Account for cases like `_, *rest, _`, where we would otherwise get
+          # the index of the first underscore.
+          first_offense_index = reverse_index(variables, first_offense)
 
-          first_offense_index = variables.index(first_offense)
-          0.upto(first_offense_index - 1).each do |index|
-            return nil if variables[index].splat_type?
-          end
+          variables[0...first_offense_index].any?(&:splat_type?)
+        end
 
-          first_offense
+        def reverse_index(collection, item)
+          collection.size - 1 - collection.reverse.index(item)
         end
 
         def allow_named_underscore_variables
@@ -73,25 +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 =
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,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
@@ -38,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?
@@ -70,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.type == :ivar
+        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.size == 1 &&
-            ![:restarg, :blockarg].include?(args.children[0].type) &&
-            body && body.type == :ivasgn &&
-            body.children[1] && body.children[1].type == :lvar
-        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
@@ -133,40 +151,28 @@ module RuboCop
           "attr_#{kind} :#{method_name.to_s.chomp('=')}"
         end
 
-        def autocorrect(node)
-          if node.type == :def
-            autocorrect_instance(node)
-          elsif node.type == :defs && node.children.first.type == :self
-            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

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

@@ -1,22 +1,32 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop looks for *unless* expressions with *else* clauses.
+      #
+      # @example
+      #   # bad
+      #   unless foo_bar.nil?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
+      #
+      #   # good
+      #   if foo_bar.present?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
       class UnlessElse < Cop
         MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
               'positive case first.'.freeze
 
         def on_if(node)
-          loc = node.loc
+          return unless node.unless? && node.else?
 
-          # discard ternary ops and modifier if/unless nodes
-          return unless loc.respond_to?(:keyword) && loc.respond_to?(:else)
-          return unless loc.keyword.is?('unless'.freeze) && loc.else
-
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)
@@ -32,15 +42,11 @@ module RuboCop
         end
 
         def range_between_condition_and_else(node, condition)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    condition.source_range.end_pos,
-                                    node.loc.else.begin_pos)
+          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
         end
 
         def range_between_else_and_end(node)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.else.end_pos,
-                                    node.loc.end.begin_pos)
+          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
         end
       end
     end

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

@@ -1,10 +1,19 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for usage of the %W() syntax when %w() would do.
+      #
+      # @example
+      #   # bad
+      #   %W(cat dog pig)
+      #   %W[door wall floor]
+      #
+      #   # good
+      #   %w/swim run bike/
+      #   %w[shirt pants shoes]
+      #   %W(apple #{fruit} grape)
       class UnneededCapitalW < Cop
         include PercentLiteral
 
@@ -15,20 +24,25 @@ module RuboCop
           process(node, '%W')
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
+        end
+
         private
 
         def on_percent_literal(node)
-          requires_interpolation = node.children.any? do |string|
-            string.type == :dstr ||
-              double_quotes_acceptable?(string.str_content)
-          end
-          add_offense(node, :expression) unless requires_interpolation
+          return if requires_interpolation?(node)
+
+          add_offense(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            src = node.loc.begin.source
-            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+        def requires_interpolation?(node)
+          node.child_nodes.any? do |string|
+            string.dstr_type? ||
+              double_quotes_required?(string.source)
           end
         end
       end