rubocop 0.51.0 → 0.52.0

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

@@ -5,10 +5,19 @@ module RuboCop
     module Style
       # This cop enforces the use of consistent method names
       # from the String class.
+      #
+      # @example
+      #   # bad
+      #   'name'.intern
+      #   'var'.unfavored_method
+      #
+      #   # good
+      #   'name'.to_sym
+      #   'var'.preferred_method
       class StringMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'.freeze
 
         def on_send(node)
           return unless preferred_method(node.method_name)
@@ -16,18 +25,20 @@ module RuboCop
           add_offense(node, location: :selector)
         end
 
-        private
-
-        def message(node)
-          format(MSG, preferred_method(node.method_name), node.method_name)
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.loc.selector,
                               preferred_method(node.method_name))
           end
         end
+
+        private
+
+        def message(node)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
+        end
       end
     end
   end

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

@@ -14,18 +14,14 @@ module RuboCop
       # cop. For example, a `MinSize of `3` will not enforce a style on an array
       # of 2 or fewer elements.
       #
-      # @example
-      #   EnforcedStyle: percent (default)
-      #
+      # @example EnforcedStyle: percent (default)
       #   # good
       #   %i[foo bar baz]
       #
       #   # bad
       #   [:foo, :bar, :baz]
       #
-      # @example
-      #   EnforcedStyle: brackets
-      #
+      # @example EnforcedStyle: brackets
       #   # good
       #   [:foo, :bar, :baz]
       #
@@ -55,8 +51,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           if style == :percent
             correct_percent(node, 'i')
@@ -65,6 +59,8 @@ module RuboCop
           end
         end
 
+        private
+
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym
@@ -73,7 +69,7 @@ module RuboCop
         end
 
         def correct_bracketed(node)
-          syms = node.children.map { |c| to_symbol_literal(c.children[0].to_s) }
+          syms = node.children.map { |c| to_symbol_literal(c.value.to_s) }
 
           lambda do |corrector|
             corrector.replace(node.source_range, "[#{syms.join(', ')}]")

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

@@ -12,7 +12,8 @@ module RuboCop
       #   # good
       #   something.map(&:upcase)
       class SymbolProc < Cop
-        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
+              'instead of a block.'.freeze
         SUPER_TYPES = %i[super zsuper].freeze
 
         def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
@@ -73,8 +74,8 @@ module RuboCop
           add_offense(node,
                       location: range,
                       message: format(MSG,
-                                      method_name,
-                                      block_method_name))
+                                      method: method_name,
+                                      block_method: block_method_name))
         end
 
         def autocorrect_method(corrector, node, args, method_name)
@@ -101,7 +102,7 @@ module RuboCop
         def block_range_with_space(node)
           block_range = range_between(begin_pos_for_replacement(node),
                                       node.loc.end.end_pos)
-          range_with_surrounding_space(block_range, :left)
+          range_with_surrounding_space(range: block_range, side: :left)
         end
 
         def begin_pos_for_replacement(node)

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

@@ -8,44 +8,35 @@ module RuboCop
       # parentheses using `EnforcedStyle`. Omission is only enforced when
       # removing the parentheses won't cause a different behavior.
       #
-      # @example
-      #
-      #   EnforcedStyle: require_no_parentheses (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: require_no_parentheses (default)
+      #   # bad
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
-      #   @good
+      #   # good
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      # @example
-      #
-      #   EnforcedStyle: require_parentheses
-      #
-      #   @bad
+      # @example EnforcedStyle: require_parentheses
+      #   # bad
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      #   @good
+      #   # good
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
-      # @example
-      #
-      #   EnforcedStyle: require_parentheses_when_complex
-      #
-      #   @bad
+      # @example EnforcedStyle: require_parentheses_when_complex
+      #   # bad
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = bar && baz ? a : b
       #
-      #   @good
+      #   # good
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
@@ -57,8 +48,8 @@ module RuboCop
         VARIABLE_TYPES = AST::Node::VARIABLES
         NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
 
-        MSG = '%s parentheses for ternary conditions.'.freeze
-        MSG_COMPLEX = '%s parentheses for ternary expressions with' \
+        MSG = '%<command>s parentheses for ternary conditions.'.freeze
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
           ' complex conditions.'.freeze
 
         def on_if(node)
@@ -67,6 +58,20 @@ module RuboCop
           add_offense(node, location: node.source_range)
         end
 
+        def autocorrect(node)
+          condition = node.condition
+
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) ||
+                        unsafe_autocorrect?(condition))
+
+          if parenthesized?(condition)
+            correct_parenthesized(condition)
+          else
+            correct_unparenthesized(condition)
+          end
+        end
+
         private
 
         def offense?(node)
@@ -85,20 +90,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          condition = node.condition
-
-          return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) ||
-                        unsafe_autocorrect?(condition))
-
-          if parenthesized?(condition)
-            correct_parenthesized(condition)
-          else
-            correct_unparenthesized(condition)
-          end
-        end
-
         # If the condition is parenthesized we recurse and check for any
         # complex expressions within it.
         def complex_condition?(condition)
@@ -124,11 +115,11 @@ module RuboCop
 
         def message(node)
           if require_parentheses_when_complex?
-            omit = parenthesized?(node.condition) ? 'Only use' : 'Use'
-            format(MSG_COMPLEX, omit)
+            command = parenthesized?(node.condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, command: command)
           else
-            verb = require_parentheses? ? 'Use' : 'Omit'
-            format(MSG, verb)
+            command = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, command: command)
           end
         end
 
@@ -195,8 +186,8 @@ module RuboCop
 
         def whitespace_after?(node)
           index = index_of_last_token(node)
-          last_token, next_token = processed_source.tokens[index, 2]
-          space_between?(last_token, next_token)
+          last_token = processed_source.tokens[index]
+          last_token.space_after?
         end
       end
     end

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