rubocop 0.51.0 → 0.52.0

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,7 +26,7 @@ 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)
@@ -35,7 +37,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
 

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

@@ -5,8 +5,30 @@ 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)
@@ -16,6 +38,14 @@ module RuboCop
         end
         alias on_defs on_def
 
+        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
 
         def in_module_or_instance_eval?(node)
@@ -42,7 +72,7 @@ module RuboCop
 
           add_offense(node,
                       location: :keyword,
-                      message: format(MSG, kind, kind))
+                      message: format(MSG, kind: kind))
         end
 
         def exact_name_match?
@@ -121,14 +151,6 @@ 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)
           kind = trivial_accessor_kind(node)
 

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

@@ -4,6 +4,21 @@ 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

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

@@ -4,6 +4,16 @@ 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
 
@@ -14,6 +24,13 @@ 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)
@@ -28,13 +45,6 @@ module RuboCop
               double_quotes_required?(string.source)
           end
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            src = node.loc.begin.source
-            corrector.replace(node.loc.begin, src.tr('W', 'w'))
-          end
-        end
       end
     end
   end

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

@@ -28,21 +28,29 @@ module RuboCop
           add_offense(node) if single_interpolation?(node)
         end
 
+        def autocorrect(node)
+          embedded_node = node.children.first
+
+          if variable_interpolation?(embedded_node)
+            autocorrect_variable_interpolation(embedded_node, node)
+          elsif single_variable_interpolation?(embedded_node)
+            autocorrect_single_variable_interpolation(embedded_node, node)
+          else
+            autocorrect_other(embedded_node, node)
+          end
+        end
+
         private
 
         def single_interpolation?(node)
-          single_child?(node) &&
+          node.children.one? &&
             interpolation?(node.children.first) &&
             !implicit_concatenation?(node) &&
             !embedded_in_percent_array?(node)
         end
 
         def single_variable_interpolation?(node)
-          single_child?(node) && variable_interpolation?(node.children.first)
-        end
-
-        def single_child?(node)
-          node.children.one?
+          node.children.one? && variable_interpolation?(node.children.first)
         end
 
         def interpolation?(node)
@@ -62,18 +70,6 @@ module RuboCop
             percent_literal?(node.parent)
         end
 
-        def autocorrect(node)
-          embedded_node = node.children.first
-
-          if variable_interpolation?(embedded_node)
-            autocorrect_variable_interpolation(embedded_node, node)
-          elsif single_variable_interpolation?(embedded_node)
-            autocorrect_single_variable_interpolation(embedded_node, node)
-          else
-            autocorrect_other(embedded_node, node)
-          end
-        end
-
         def autocorrect_variable_interpolation(embedded_node, node)
           replacement = "#{embedded_node.loc.expression.source}.to_s"
           ->(corrector) { corrector.replace(node.loc.expression, replacement) }

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
       class UnneededPercentQ < Cop
-        MSG = 'Use `%s` only for strings that contain both single quotes and ' \
-              'double quotes%s.'.freeze
+        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
+              'single quotes and double quotes%<extra>s.'.freeze
         DYNAMIC_MSG = ', or for dynamic strings that contain ' \
                       'double quotes'.freeze
         SINGLE_QUOTE = "'".freeze
@@ -18,6 +18,7 @@ module RuboCop
         ESCAPED_NON_BACKSLASH = /\\[^\\]/
 
         def on_dstr(node)
+          return unless string_literal?(node)
           check(node)
         end
 
@@ -29,6 +30,15 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          delimiter =
+            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+
         private
 
         def check(node)
@@ -55,16 +65,7 @@ module RuboCop
                   else
                     EMPTY
                   end
-          format(MSG, src[0, 2], extra)
-        end
-
-        def autocorrect(node)
-          delimiter =
-            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
+          format(MSG, q_type: src[0, 2], extra: extra)
         end
 
         def string_literal?(node)

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

@@ -4,9 +4,20 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for variable interpolation (like "#@ivar").
+      #
+      # @example
+      #   # bad
+      #   "His name is #$name"
+      #   /check #$pattern/
+      #   "Let's go to the #@store"
+      #
+      #   # good
+      #   "His name is #{$name}"
+      #   /check #{$pattern}/
+      #   "Let's go to the #{@store}"
       class VariableInterpolation < Cop
-        MSG = 'Replace interpolated variable `%s` ' \
-              'with expression `#{%s}`.'.freeze
+        MSG = 'Replace interpolated variable `%<variable>s` ' \
+              'with expression `#{%<variable>s}`.'.freeze
 
         def on_dstr(node)
           check_for_interpolation(node)
@@ -20,6 +31,12 @@ module RuboCop
           check_for_interpolation(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, "{#{node.source}}")
+          end
+        end
+
         private
 
         def check_for_interpolation(node)
@@ -29,13 +46,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.source, node.source)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
-          end
+          format(MSG, variable: node.source)
         end
 
         def var_nodes(nodes)

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

@@ -4,6 +4,19 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for *when;* uses in *case* expressions.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when 1; 'baz'
+      #   when 2; 'bar'
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when 1 then 'baz'
+      #   when 2 then 'bar'
+      #   end
       class WhenThen < Cop
         MSG = 'Do not use `when x;`. Use `when x then` instead.'.freeze
 

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

@@ -4,8 +4,32 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of `do` in multi-line `while/until` statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   while x.any? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   while x.any?
+      #     do_something(x.pop)
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   until x.empty? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   until x.empty?
+      #     do_something(x.pop)
+      #   end
       class WhileUntilDo < Cop
-        MSG = 'Do not use `do` with multi-line `%s`.'.freeze
+        MSG = 'Do not use `do` with multi-line `%<keyword>s`.'.freeze
 
         def on_while(node)
           handle(node)
@@ -19,11 +43,9 @@ module RuboCop
           return unless node.multiline? && node.do?
 
           add_offense(node, location: :begin,
-                            message: format(MSG, node.keyword))
+                            message: format(MSG, keyword: node.keyword))
         end
 
-        private
-
         def autocorrect(node)
           do_range = node.condition.source_range.end.join(node.loc.begin)